Datasets:

---

iNeil77

/

the-vault-function

like 0

[ "MIT" ]

[ "return", "true", "if", "my", "timestamp", "is", "after", "the", "right", "timestamp", "." ]

[ "bool", "after", "(", "timeval", "right", ")", "{", "return", "mTime", ".", "tv_sec", ">", "right", ".", "tv_sec", "||", "(", "mTime", ".", "tv_sec", "==", "right", ".", "tv_sec", "&&", "mTime", ".", "tv_usec", ">", "right", ".", "tv_usec", ")", ";", "}" ]

[ "return", "true", "if", "my", "timestamp", "is", "after", "the", "right", "timestamp", "." ]

[]

[ { "param": "right", "type": "timeval" } ]

[ "MIT" ]

[ "This", "function", "returns", "the", "fraction", "of", "time", "elapsed", "after", "the", "beginning", "till", "the", "end" ]

[ "double", "fraction", "(", "Timestamp", "currentTime", ",", "Timestamp", "endTime", ")", "{", "if", "(", "(", "currentTime", ".", "after", "(", "*", "this", ")", ")", "&&", "(", "endTime", ".", "after", "(", "currentTime", ")", ")", ")", "{", "return", "(", "(", "(", "double", ")", "currentTime", ".", "subUsec", "(", "*", "this", ")", ")", "/", "(", "(", "double", ")", "endTime", ".", "subUsec", "(", "*", "this", ")", ")", ")", ";", "}", "else", "{", "return", "-1.0", ";", "}", "}" ]

[ "This", "function", "returns", "the", "fraction", "of", "time", "elapsed", "after", "the", "beginning", "till", "the", "end" ]

[]

[ { "param": "currentTime", "type": "Timestamp" }, { "param": "endTime", "type": "Timestamp" } ]

[ "MIT" ]

[ "unpacks", "ISO", "Numeric", "(", "bcd", "format", ")", "NB", "if", "iSize", "is", "odd", "then", "we", "have", "a", "padding", "char", "on", "left", "(", "but", "don", "'", "t", "include", "when", "unpacking", ")", "NB", "doesn", "'", "t", "remove", "any", "leading", "padding", "(", "0", "nibbles", ")" ]

[ "DL_ERR", "_unpack_iso_ASCHEX", "(", "DL_UINT16", "iField", ",", "DL_ISO8583_MSG", "*", "ioMsg", ",", "const", "DL_ISO8583_FIELD_DEF", "*", "iFieldDefPtr", ",", "DL_UINT8", "*", "*", "ioPtr", ")", "{", "DL_ERR", "err", "=", "kDL_ERR_NONE", ";", "DL_UINT8", "*", "tmpPtr", "=", "*", "ioPtr", ";", "DL_UINT16", "size", "=", "0", ";", "DL_UINT8", "*", "tmpDataPtr", "=", "NULL", ";", "err", "=", "VarLen_Get", "(", "&", "tmpPtr", ",", "iFieldDefPtr", "->", "varLen", ",", "iFieldDefPtr", "->", "len", ",", "&", "size", ")", ";", "if", "(", "!", "err", ")", "err", "=", "_DL_ISO8583_MSG_AllocField", "(", "iField", ",", "size", ",", "ioMsg", ",", "&", "tmpDataPtr", ")", ";", "if", "(", "!", "err", ")", "{", "DL_UINT8", "ch", ";", "if", "(", "size", "%", "2", ")", "{", "ch", "=", "*", "tmpPtr", "&", "0x0f", ";", "*", "tmpDataPtr", "++", "=", "DL_NIBBLE_2_ASCHEX", "(", "ch", ")", ";", "tmpPtr", "++", ";", "size", "-=", "1", ";", "}", "size", "/=", "2", ";", "while", "(", "size", "--", ">", "0", ")", "{", "ch", "=", "(", "*", "tmpPtr", ">>", "4", ")", "&", "0xf", ";", "*", "tmpDataPtr", "++", "=", "DL_NIBBLE_2_ASCHEX", "(", "ch", ")", ";", "ch", "=", "*", "tmpPtr", "&", "0xf", ";", "*", "tmpDataPtr", "++", "=", "DL_NIBBLE_2_ASCHEX", "(", "ch", ")", ";", "tmpPtr", "++", ";", "}", "*", "tmpDataPtr", "=", "kDL_ASCII_NULL", ";", "}", "*", "ioPtr", "=", "tmpPtr", ";", "return", "err", ";", "}" ]

[ "unpacks", "ISO", "Numeric", "(", "bcd", "format", ")", "NB", "if", "iSize", "is", "odd", "then", "we", "have", "a", "padding", "char", "on", "left", "(", "but", "don", "'", "t", "include", "when", "unpacking", ")", "NB", "doesn", "'", "t", "remove", "any", "leading", "padding", "(", "0", "nibbles", ")" ]

[ "/* variable length handling */", "/* allocate field */", "/* if size is 'odd' then ignore the leading nibble, as this is a pad character */", "/* odd */", "/* null terminate */" ]

[ { "param": "iField", "type": "DL_UINT16" }, { "param": "ioMsg", "type": "DL_ISO8583_MSG" }, { "param": "iFieldDefPtr", "type": "DL_ISO8583_FIELD_DEF" }, { "param": "ioPtr", "type": "DL_UINT8" } ]

[ "MIT" ]

[ "outputs", "the", "variable", "length", "element", "iVarLenType", "-", "e", ".", "g", "." ]

[ "static", "DL_ERR", "VarLen_Put", "(", "DL_UINT8", "iVarLenType", ",", "DL_UINT32", "iActLen", ",", "DL_UINT32", "*", "ioReqLen", ",", "DL_UINT8", "*", "*", "ioPtr", ")", "{", "DL_ERR", "err", "=", "kDL_ERR_NONE", ";", "DL_UINT8", "*", "tmpPtr", "=", "*", "ioPtr", ";", "switch", "(", "iVarLenType", ")", "{", "case", "kDL_ISO8583_FIXED", ":", "break", ";", "case", "kDL_ISO8583_LLVAR", ":", "iActLen", "%=", "100", ";", "*", "ioReqLen", "=", "iActLen", ";", "*", "tmpPtr", "++", "=", "output_bcd_byte", "(", "iActLen", ")", ";", "break", ";", "case", "kDL_ISO8583_LLLVAR", ":", "iActLen", "%=", "1000", ";", "*", "ioReqLen", "=", "iActLen", ";", "*", "tmpPtr", "++", "=", "output_bcd_byte", "(", "iActLen", "/", "100", ")", ";", "*", "tmpPtr", "++", "=", "output_bcd_byte", "(", "iActLen", "%", "100", ")", ";", "break", ";", "case", "kDL_ISO8583_LLLLVAR", ":", "iActLen", "%=", "10000", ";", "*", "ioReqLen", "=", "iActLen", ";", "*", "tmpPtr", "++", "=", "output_bcd_byte", "(", "iActLen", "/", "100", ")", ";", "*", "tmpPtr", "++", "=", "output_bcd_byte", "(", "iActLen", "%", "100", ")", ";", "break", ";", "default", ":", "err", "=", "kDL_ERR_OTHER", ";", "}", "*", "ioPtr", "=", "tmpPtr", ";", "return", "err", ";", "}" ]

[ "outputs", "the", "variable", "length", "element", "iVarLenType", "-", "e", ".", "g", "." ]

[ "/* do nothing */", "/* [ERROR] unsupported length type */", "/* end-switch */" ]

[ { "param": "iVarLenType", "type": "DL_UINT8" }, { "param": "iActLen", "type": "DL_UINT32" }, { "param": "ioReqLen", "type": "DL_UINT32" }, { "param": "ioPtr", "type": "DL_UINT8" } ]

[ "MIT" ]

[ "@brief", "Initializes", "the", "FSMC", "NOR", "/", "SRAM", "Banks", "according", "to", "the", "specified", "parameters", "in", "the", "FSMC_NORSRAMInitStruct", ".", "@param", "FSMC_NORSRAMInitStruct", ":", "pointer", "to", "a", "FSMC_NORSRAMInitTypeDef", "structure", "that", "contains", "the", "configuration", "information", "for", "the", "FSMC", "NOR", "/", "SRAM", "specified", "Banks", ".", "@retval", "None" ]

[ "void", "FSMC_NORSRAMInit", "(", "FSMC_NORSRAMInitTypeDef", "*", "FSMC_NORSRAMInitStruct", ")", "{", "assert_param", "(", "IS_FSMC_NORSRAM_BANK", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_Bank", ")", ")", ";", "assert_param", "(", "IS_FSMC_MUX", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_DataAddressMux", ")", ")", ";", "assert_param", "(", "IS_FSMC_MEMORY", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_MemoryType", ")", ")", ";", "assert_param", "(", "IS_FSMC_MEMORY_WIDTH", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_MemoryDataWidth", ")", ")", ";", "assert_param", "(", "IS_FSMC_BURSTMODE", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_BurstAccessMode", ")", ")", ";", "assert_param", "(", "IS_FSMC_ASYNWAIT", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_AsynchronousWait", ")", ")", ";", "assert_param", "(", "IS_FSMC_WAIT_POLARITY", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WaitSignalPolarity", ")", ")", ";", "assert_param", "(", "IS_FSMC_WRAP_MODE", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WrapMode", ")", ")", ";", "assert_param", "(", "IS_FSMC_WAIT_SIGNAL_ACTIVE", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WaitSignalActive", ")", ")", ";", "assert_param", "(", "IS_FSMC_WRITE_OPERATION", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteOperation", ")", ")", ";", "assert_param", "(", "IS_FSMC_WAITE_SIGNAL", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WaitSignal", ")", ")", ";", "assert_param", "(", "IS_FSMC_EXTENDED_MODE", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_ExtendedMode", ")", ")", ";", "assert_param", "(", "IS_FSMC_WRITE_BURST", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteBurst", ")", ")", ";", "assert_param", "(", "IS_FSMC_ADDRESS_SETUP_TIME", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_ReadWriteTimingStruct", "->", "FSMC_AddressSetupTime", ")", ")", ";", "assert_param", "(", "IS_FSMC_ADDRESS_HOLD_TIME", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_ReadWriteTimingStruct", "->", "FSMC_AddressHoldTime", ")", ")", ";", "assert_param", "(", "IS_FSMC_DATASETUP_TIME", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_ReadWriteTimingStruct", "->", "FSMC_DataSetupTime", ")", ")", ";", "assert_param", "(", "IS_FSMC_TURNAROUND_TIME", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_ReadWriteTimingStruct", "->", "FSMC_BusTurnAroundDuration", ")", ")", ";", "assert_param", "(", "IS_FSMC_CLK_DIV", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_ReadWriteTimingStruct", "->", "FSMC_CLKDivision", ")", ")", ";", "assert_param", "(", "IS_FSMC_DATA_LATENCY", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_ReadWriteTimingStruct", "->", "FSMC_DataLatency", ")", ")", ";", "assert_param", "(", "IS_FSMC_ACCESS_MODE", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_ReadWriteTimingStruct", "->", "FSMC_AccessMode", ")", ")", ";", "FSMC_Bank1", "->", "BTCR", "[", "FSMC_NORSRAMInitStruct", "->", "FSMC_Bank", "]", "=", "(", "uint32_t", ")", "FSMC_NORSRAMInitStruct", "->", "FSMC_DataAddressMux", "|", "FSMC_NORSRAMInitStruct", "->", "FSMC_MemoryType", "|", "FSMC_NORSRAMInitStruct", "->", "FSMC_MemoryDataWidth", "|", "FSMC_NORSRAMInitStruct", "->", "FSMC_BurstAccessMode", "|", "FSMC_NORSRAMInitStruct", "->", "FSMC_AsynchronousWait", "|", "FSMC_NORSRAMInitStruct", "->", "FSMC_WaitSignalPolarity", "|", "FSMC_NORSRAMInitStruct", "->", "FSMC_WrapMode", "|", "FSMC_NORSRAMInitStruct", "->", "FSMC_WaitSignalActive", "|", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteOperation", "|", "FSMC_NORSRAMInitStruct", "->", "FSMC_WaitSignal", "|", "FSMC_NORSRAMInitStruct", "->", "FSMC_ExtendedMode", "|", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteBurst", ";", "if", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_MemoryType", "==", "FSMC_MemoryType_NOR", ")", "{", "FSMC_Bank1", "->", "BTCR", "[", "FSMC_NORSRAMInitStruct", "->", "FSMC_Bank", "]", "|=", "(", "uint32_t", ")", "FSMC_BCR1_FACCEN", ";", "}", "FSMC_Bank1", "->", "BTCR", "[", "FSMC_NORSRAMInitStruct", "->", "FSMC_Bank", "+", "1", "]", "=", "(", "uint32_t", ")", "FSMC_NORSRAMInitStruct", "->", "FSMC_ReadWriteTimingStruct", "->", "FSMC_AddressSetupTime", "|", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_ReadWriteTimingStruct", "->", "FSMC_AddressHoldTime", "<<", "4", ")", "|", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_ReadWriteTimingStruct", "->", "FSMC_DataSetupTime", "<<", "8", ")", "|", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_ReadWriteTimingStruct", "->", "FSMC_BusTurnAroundDuration", "<<", "16", ")", "|", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_ReadWriteTimingStruct", "->", "FSMC_CLKDivision", "<<", "20", ")", "|", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_ReadWriteTimingStruct", "->", "FSMC_DataLatency", "<<", "24", ")", "|", "FSMC_NORSRAMInitStruct", "->", "FSMC_ReadWriteTimingStruct", "->", "FSMC_AccessMode", ";", "if", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_ExtendedMode", "==", "FSMC_ExtendedMode_Enable", ")", "{", "assert_param", "(", "IS_FSMC_ADDRESS_SETUP_TIME", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteTimingStruct", "->", "FSMC_AddressSetupTime", ")", ")", ";", "assert_param", "(", "IS_FSMC_ADDRESS_HOLD_TIME", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteTimingStruct", "->", "FSMC_AddressHoldTime", ")", ")", ";", "assert_param", "(", "IS_FSMC_DATASETUP_TIME", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteTimingStruct", "->", "FSMC_DataSetupTime", ")", ")", ";", "assert_param", "(", "IS_FSMC_CLK_DIV", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteTimingStruct", "->", "FSMC_CLKDivision", ")", ")", ";", "assert_param", "(", "IS_FSMC_DATA_LATENCY", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteTimingStruct", "->", "FSMC_DataLatency", ")", ")", ";", "assert_param", "(", "IS_FSMC_ACCESS_MODE", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteTimingStruct", "->", "FSMC_AccessMode", ")", ")", ";", "FSMC_Bank1E", "->", "BWTR", "[", "FSMC_NORSRAMInitStruct", "->", "FSMC_Bank", "]", "=", "(", "uint32_t", ")", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteTimingStruct", "->", "FSMC_AddressSetupTime", "|", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteTimingStruct", "->", "FSMC_AddressHoldTime", "<<", "4", ")", "|", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteTimingStruct", "->", "FSMC_DataSetupTime", "<<", "8", ")", "|", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteTimingStruct", "->", "FSMC_CLKDivision", "<<", "20", ")", "|", "(", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteTimingStruct", "->", "FSMC_DataLatency", "<<", "24", ")", "|", "FSMC_NORSRAMInitStruct", "->", "FSMC_WriteTimingStruct", "->", "FSMC_AccessMode", ";", "}", "else", "{", "FSMC_Bank1E", "->", "BWTR", "[", "FSMC_NORSRAMInitStruct", "->", "FSMC_Bank", "]", "=", "0x0FFFFFFF", ";", "}", "}" ]

[ "@brief", "Initializes", "the", "FSMC", "NOR", "/", "SRAM", "Banks", "according", "to", "the", "specified", "parameters", "in", "the", "FSMC_NORSRAMInitStruct", "." ]

[ "/* Check the parameters */", "/* Bank1 NOR/SRAM control register configuration */", "/* Bank1 NOR/SRAM timing register configuration */", "/* Bank1 NOR/SRAM timing register for write configuration, if extended mode is used */" ]

[ { "param": "FSMC_NORSRAMInitStruct", "type": "FSMC_NORSRAMInitTypeDef" } ]

[ "MIT" ]

[ "@brief", "Enables", "or", "disables", "the", "specified", "NOR", "/", "SRAM", "Memory", "Bank", "." ]

[ "void", "FSMC_NORSRAMCmd", "(", "uint32_t", "FSMC_Bank", ",", "FunctionalState", "NewState", ")", "{", "assert_param", "(", "IS_FSMC_NORSRAM_BANK", "(", "FSMC_Bank", ")", ")", ";", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "if", "(", "NewState", "!=", "DISABLE", ")", "{", "FSMC_Bank1", "->", "BTCR", "[", "FSMC_Bank", "]", "|=", "FSMC_BCR1_MBKEN", ";", "}", "else", "{", "FSMC_Bank1", "->", "BTCR", "[", "FSMC_Bank", "]", "&=", "(", "uint32_t", ")", "(", "~", "FSMC_BCR1_MBKEN", ")", ";", "}", "}" ]

[ "@brief", "Enables", "or", "disables", "the", "specified", "NOR", "/", "SRAM", "Memory", "Bank", "." ]

[ "/* Enable the selected NOR/SRAM Bank by setting the MBKEN bit in the BCRx register */", "/* Disable the selected NOR/SRAM Bank by clearing the MBKEN bit in the BCRx register */" ]

[ { "param": "FSMC_Bank", "type": "uint32_t" }, { "param": "NewState", "type": "FunctionalState" } ]

[ "MIT" ]

[ "@brief", "Deinitializes", "the", "SPIx", "peripheral", "registers", "to", "their", "default", "reset", "values", ".", "@param", "SPIx", ":", "To", "select", "the", "SPIx", "/", "I2Sx", "peripheral", "where", "x", "can", "be", ":", "1", "2", "or", "3", "in", "SPI", "mode", "or", "2", "or", "3", "in", "I2S", "mode", ".", "@retval", "None" ]

[ "void", "SPI_I2S_DeInit", "(", "SPI_TypeDef", "*", "SPIx", ")", "{", "assert_param", "(", "IS_SPI_ALL_PERIPH", "(", "SPIx", ")", ")", ";", "if", "(", "SPIx", "==", "SPI1", ")", "{", "RCC_APB2PeriphResetCmd", "(", "RCC_APB2Periph_SPI1", ",", "ENABLE", ")", ";", "RCC_APB2PeriphResetCmd", "(", "RCC_APB2Periph_SPI1", ",", "DISABLE", ")", ";", "}", "else", "if", "(", "SPIx", "==", "SPI2", ")", "{", "RCC_APB1PeriphResetCmd", "(", "RCC_APB1Periph_SPI2", ",", "ENABLE", ")", ";", "RCC_APB1PeriphResetCmd", "(", "RCC_APB1Periph_SPI2", ",", "DISABLE", ")", ";", "}", "else", "{", "if", "(", "SPIx", "==", "SPI3", ")", "{", "RCC_APB1PeriphResetCmd", "(", "RCC_APB1Periph_SPI3", ",", "ENABLE", ")", ";", "RCC_APB1PeriphResetCmd", "(", "RCC_APB1Periph_SPI3", ",", "DISABLE", ")", ";", "}", "}", "}" ]

[ "@brief", "Deinitializes", "the", "SPIx", "peripheral", "registers", "to", "their", "default", "reset", "values", "." ]

[ "/* Check the parameters */", "/* Enable SPI1 reset state */", "/* Release SPI1 from reset state */", "/* Enable SPI2 reset state */", "/* Release SPI2 from reset state */", "/* Enable SPI3 reset state */", "/* Release SPI3 from reset state */" ]

[ { "param": "SPIx", "type": "SPI_TypeDef" } ]

[ "MIT" ]

[ "@brief", "Initializes", "the", "SPIx", "peripheral", "according", "to", "the", "specified", "parameters", "in", "the", "I2S_InitStruct", ".", "@param", "SPIx", ":", "where", "x", "can", "be", "2", "or", "3", "to", "select", "the", "SPI", "peripheral", "(", "configured", "in", "I2S", "mode", ")", ".", "@param", "I2S_InitStruct", ":", "pointer", "to", "an", "I2S_InitTypeDef", "structure", "that", "contains", "the", "configuration", "information", "for", "the", "specified", "SPI", "peripheral", "configured", "in", "I2S", "mode", ".", "@note", "The", "function", "calculates", "the", "optimal", "prescaler", "needed", "to", "obtain", "the", "most", "accurate", "audio", "frequency", "(", "depending", "on", "the", "I2S", "clock", "source", "the", "PLL", "values", "and", "the", "product", "configuration", ")", ".", "But", "in", "case", "the", "prescaler", "value", "is", "greater", "than", "511", "the", "default", "value", "(", "0x02", ")", "will", "be", "configured", "instead", ".", "@retval", "None" ]

[ "void", "I2S_Init", "(", "SPI_TypeDef", "*", "SPIx", ",", "I2S_InitTypeDef", "*", "I2S_InitStruct", ")", "{", "uint16_t", "tmpreg", "=", "0", ",", "i2sdiv", "=", "2", ",", "i2sodd", "=", "0", ",", "packetlength", "=", "1", ";", "uint32_t", "tmp", "=", "0", ";", "RCC_ClocksTypeDef", "RCC_Clocks", ";", "uint32_t", "sourceclock", "=", "0", ";", "assert_param", "(", "IS_SPI_23_PERIPH", "(", "SPIx", ")", ")", ";", "assert_param", "(", "IS_I2S_MODE", "(", "I2S_InitStruct", "->", "I2S_Mode", ")", ")", ";", "assert_param", "(", "IS_I2S_STANDARD", "(", "I2S_InitStruct", "->", "I2S_Standard", ")", ")", ";", "assert_param", "(", "IS_I2S_DATA_FORMAT", "(", "I2S_InitStruct", "->", "I2S_DataFormat", ")", ")", ";", "assert_param", "(", "IS_I2S_MCLK_OUTPUT", "(", "I2S_InitStruct", "->", "I2S_MCLKOutput", ")", ")", ";", "assert_param", "(", "IS_I2S_AUDIO_FREQ", "(", "I2S_InitStruct", "->", "I2S_AudioFreq", ")", ")", ";", "assert_param", "(", "IS_I2S_CPOL", "(", "I2S_InitStruct", "->", "I2S_CPOL", ")", ")", ";", "SPIx", "->", "I2SCFGR", "&=", "I2SCFGR_CLEAR_Mask", ";", "SPIx", "->", "I2SPR", "=", "0x0002", ";", "tmpreg", "=", "SPIx", "->", "I2SCFGR", ";", "if", "(", "I2S_InitStruct", "->", "I2S_AudioFreq", "==", "I2S_AudioFreq_Default", ")", "{", "i2sodd", "=", "(", "uint16_t", ")", "0", ";", "i2sdiv", "=", "(", "uint16_t", ")", "2", ";", "}", "else", "{", "if", "(", "I2S_InitStruct", "->", "I2S_DataFormat", "==", "I2S_DataFormat_16b", ")", "{", "packetlength", "=", "1", ";", "}", "else", "{", "packetlength", "=", "2", ";", "}", "RCC_GetClocksFreq", "(", "&", "RCC_Clocks", ")", ";", "sourceclock", "=", "RCC_Clocks", ".", "SYSCLK_Frequency", ";", "if", "(", "I2S_InitStruct", "->", "I2S_MCLKOutput", "==", "I2S_MCLKOutput_Enable", ")", "{", "tmp", "=", "(", "uint16_t", ")", "(", "(", "(", "(", "(", "sourceclock", "/", "256", ")", "*", "10", ")", "/", "I2S_InitStruct", "->", "I2S_AudioFreq", ")", ")", "+", "5", ")", ";", "}", "else", "{", "tmp", "=", "(", "uint16_t", ")", "(", "(", "(", "(", "(", "sourceclock", "/", "(", "32", "*", "packetlength", ")", ")", "*", "10", ")", "/", "I2S_InitStruct", "->", "I2S_AudioFreq", ")", ")", "+", "5", ")", ";", "}", "tmp", "=", "tmp", "/", "10", ";", "i2sodd", "=", "(", "uint16_t", ")", "(", "tmp", "&", "(", "uint16_t", ")", "0x0001", ")", ";", "i2sdiv", "=", "(", "uint16_t", ")", "(", "(", "tmp", "-", "i2sodd", ")", "/", "2", ")", ";", "i2sodd", "=", "(", "uint16_t", ")", "(", "i2sodd", "<<", "8", ")", ";", "}", "if", "(", "(", "i2sdiv", "<", "2", ")", "||", "(", "i2sdiv", ">", "0xFF", ")", ")", "{", "i2sdiv", "=", "2", ";", "i2sodd", "=", "0", ";", "}", "SPIx", "->", "I2SPR", "=", "(", "uint16_t", ")", "(", "i2sdiv", "|", "(", "uint16_t", ")", "(", "i2sodd", "|", "(", "uint16_t", ")", "I2S_InitStruct", "->", "I2S_MCLKOutput", ")", ")", ";", "tmpreg", "|=", "(", "uint16_t", ")", "(", "SPI_I2SCFGR_I2SMOD", "|", "(", "uint16_t", ")", "(", "I2S_InitStruct", "->", "I2S_Mode", "|", "(", "uint16_t", ")", "(", "I2S_InitStruct", "->", "I2S_Standard", "|", "(", "uint16_t", ")", "(", "I2S_InitStruct", "->", "I2S_DataFormat", "|", "(", "uint16_t", ")", "I2S_InitStruct", "->", "I2S_CPOL", ")", ")", ")", ")", ";", "SPIx", "->", "I2SCFGR", "=", "tmpreg", ";", "}" ]

[ "@brief", "Initializes", "the", "SPIx", "peripheral", "according", "to", "the", "specified", "parameters", "in", "the", "I2S_InitStruct", "." ]

[ "/* Check the I2S parameters */", "/*----------------------- SPIx I2SCFGR & I2SPR Configuration -----------------*/", "/* Clear I2SMOD, I2SE, I2SCFG, PCMSYNC, I2SSTD, CKPOL, DATLEN and CHLEN bits */", "/* Get the I2SCFGR register value */", "/* If the default value has to be written, reinitialize i2sdiv and i2sodd*/", "/* If the requested audio frequency is not the default, compute the prescaler */", "/* Check the frame length (For the Prescaler computing) */", "/* Packet length is 16 bits */", "/* Packet length is 32 bits */", "/* I2S Clock source is System clock: Get System Clock frequency */", "/* Get the source clock value: based on System Clock value */", "/* Compute the Real divider depending on the MCLK output state with a flaoting point */", "/* MCLK output is enabled */", "/* MCLK output is disabled */", "/* Remove the flaoting point */", "/* Check the parity of the divider */", "/* Compute the i2sdiv prescaler */", "/* Get the Mask for the Odd bit (SPI_I2SPR[8]) register */", "/* Test if the divider is 1 or 0 or greater than 0xFF */", "/* Set the default values */", "/* Write to SPIx I2SPR register the computed value */", "/* Configure the I2S with the SPI_InitStruct values */", "/* Write to SPIx I2SCFGR */" ]

[ { "param": "SPIx", "type": "SPI_TypeDef" }, { "param": "I2S_InitStruct", "type": "I2S_InitTypeDef" } ]

[ "MIT" ]

[ "@brief", "Enables", "or", "disables", "the", "specified", "SPI", "peripheral", "(", "in", "I2S", "mode", ")", ".", "@param", "SPIx", ":", "where", "x", "can", "be", "2", "or", "3", "to", "select", "the", "SPI", "peripheral", ".", "@param", "NewState", ":", "new", "state", "of", "the", "SPIx", "peripheral", ".", "This", "parameter", "can", "be", ":", "ENABLE", "or", "DISABLE", ".", "@retval", "None" ]

[ "void", "I2S_Cmd", "(", "SPI_TypeDef", "*", "SPIx", ",", "FunctionalState", "NewState", ")", "{", "assert_param", "(", "IS_SPI_23_PERIPH", "(", "SPIx", ")", ")", ";", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "if", "(", "NewState", "!=", "DISABLE", ")", "{", "SPIx", "->", "I2SCFGR", "|=", "SPI_I2SCFGR_I2SE", ";", "}", "else", "{", "SPIx", "->", "I2SCFGR", "&=", "(", "uint16_t", ")", "~", "(", "(", "uint16_t", ")", "SPI_I2SCFGR_I2SE", ")", ";", "}", "}" ]

[ "@brief", "Enables", "or", "disables", "the", "specified", "SPI", "peripheral", "(", "in", "I2S", "mode", ")", "." ]

[ "/* Check the parameters */", "/* Enable the selected SPI peripheral (in I2S mode) */", "/* Disable the selected SPI peripheral in I2S mode */" ]

[ { "param": "SPIx", "type": "SPI_TypeDef" }, { "param": "NewState", "type": "FunctionalState" } ]

[ "MIT" ]

[ "@brief", "Transmits", "a", "Data", "through", "the", "SPIx", "/", "I2Sx", "peripheral", ".", "@param", "SPIx", ":", "To", "select", "the", "SPIx", "/", "I2Sx", "peripheral", "where", "x", "can", "be", ":", "1", "2", "or", "3", "in", "SPI", "mode", "or", "2", "or", "3", "in", "I2S", "mode", ".", "@param", "Data", ":", "Data", "to", "be", "transmitted", ".", "@retval", "None" ]

[ "void", "SPI_I2S_SendData", "(", "SPI_TypeDef", "*", "SPIx", ",", "uint16_t", "Data", ")", "{", "assert_param", "(", "IS_SPI_ALL_PERIPH", "(", "SPIx", ")", ")", ";", "SPIx", "->", "DR", "=", "Data", ";", "}" ]

[ "@brief", "Transmits", "a", "Data", "through", "the", "SPIx", "/", "I2Sx", "peripheral", "." ]

[ "/* Check the parameters */", "/* Write in the DR register the data to be sent */" ]

[ { "param": "SPIx", "type": "SPI_TypeDef" }, { "param": "Data", "type": "uint16_t" } ]

[ "MIT" ]

[ "@brief", "Resets", "the", "RCC", "clock", "configuration", "to", "the", "default", "reset", "state", ".", "@note", "The", "default", "reset", "state", "of", "the", "clock", "configuration", "is", "given", "below", ":", "@note", "MSI", "ON", "and", "used", "as", "system", "clock", "source", "(", "MSI", "range", "is", "not", "modified", "by", "this", "function", "it", "keep", "the", "value", "configured", "by", "user", "application", ")", "@note", "HSI", "HSE", "and", "PLL", "OFF", "@note", "AHB", "APB1", "and", "APB2", "prescaler", "set", "to", "1", "." ]

[ "void", "RCC_DeInit", "(", "void", ")", "{", "RCC", "->", "CR", "|=", "(", "uint32_t", ")", "0x00000100", ";", "RCC", "->", "CFGR", "&=", "(", "uint32_t", ")", "0x88FFC00C", ";", "RCC", "->", "CR", "&=", "(", "uint32_t", ")", "0xEEFEFFFE", ";", "RCC", "->", "CR", "&=", "(", "uint32_t", ")", "0xFFFBFFFF", ";", "RCC", "->", "CFGR", "&=", "(", "uint32_t", ")", "0xFF02FFFF", ";", "RCC", "->", "CIR", "=", "0x00000000", ";", "}" ]

[ "@brief", "Resets", "the", "RCC", "clock", "configuration", "to", "the", "default", "reset", "state", "." ]

[ "/* Set MSION bit */", "/* Reset SW[1:0], HPRE[3:0], PPRE1[2:0], PPRE2[2:0], MCOSEL[2:0] and MCOPRE[2:0] bits */", "/* Reset HSION, HSEON, CSSON and PLLON bits */", "/* Reset HSEBYP bit */", "/* Reset PLLSRC, PLLMUL[3:0] and PLLDIV[1:0] bits */", "/* Disable all interrupts */" ]

[]

[ "MIT" ]

[ "@brief", "Configures", "the", "Internal", "Multi", "Speed", "oscillator", "(", "MSI", ")", "clock", "range", ".", "@note", "After", "restart", "from", "Reset", "or", "wakeup", "from", "STANDBY", "the", "MSI", "clock", "is", "around", "2", ".", "097", "MHz", ".", "The", "MSI", "clock", "does", "not", "change", "after", "wake", "-", "up", "from", "STOP", "mode", ".", "@note", "The", "MSI", "clock", "range", "can", "be", "modified", "on", "the", "fly", ".", "@param", "RCC_MSIRange", ":", "specifies", "the", "MSI", "Clock", "range", ".", "@retval", "None" ]

[ "void", "RCC_MSIRangeConfig", "(", "uint32_t", "RCC_MSIRange", ")", "{", "uint32_t", "tmpreg", "=", "0", ";", "assert_param", "(", "IS_RCC_MSI_CLOCK_RANGE", "(", "RCC_MSIRange", ")", ")", ";", "tmpreg", "=", "RCC", "->", "ICSCR", ";", "tmpreg", "&=", "~", "RCC_ICSCR_MSIRANGE", ";", "tmpreg", "|=", "(", "uint32_t", ")", "RCC_MSIRange", ";", "RCC", "->", "ICSCR", "=", "tmpreg", ";", "}" ]

[ "@brief", "Configures", "the", "Internal", "Multi", "Speed", "oscillator", "(", "MSI", ")", "clock", "range", "." ]

[ "/* Check the parameters */", "/* Clear MSIRANGE[2:0] bits */", "/* Set the MSIRANGE[2:0] bits according to RCC_MSIRange value */", "/* Store the new value */" ]

[ { "param": "RCC_MSIRange", "type": "uint32_t" } ]

[ "MIT" ]

[ "@brief", "Adjusts", "the", "Internal", "High", "Speed", "oscillator", "(", "HSI", ")", "calibration", "value", ".", "@note", "The", "calibration", "is", "used", "to", "compensate", "for", "the", "variations", "in", "voltage", "and", "temperature", "that", "influence", "the", "frequency", "of", "the", "internal", "HSI", "RC", ".", "Refer", "to", "the", "Application", "Note", "AN3300", "for", "more", "details", "on", "how", "to", "calibrate", "the", "HSI", ".", "@param", "HSICalibrationValue", ":", "specifies", "the", "HSI", "calibration", "trimming", "value", ".", "This", "parameter", "must", "be", "a", "number", "between", "0", "and", "0x1F", ".", "@retval", "None" ]

[ "void", "RCC_AdjustHSICalibrationValue", "(", "uint8_t", "HSICalibrationValue", ")", "{", "uint32_t", "tmpreg", "=", "0", ";", "assert_param", "(", "IS_RCC_HSI_CALIBRATION_VALUE", "(", "HSICalibrationValue", ")", ")", ";", "tmpreg", "=", "RCC", "->", "ICSCR", ";", "tmpreg", "&=", "~", "RCC_ICSCR_HSITRIM", ";", "tmpreg", "|=", "(", "uint32_t", ")", "HSICalibrationValue", "<<", "8", ";", "RCC", "->", "ICSCR", "=", "tmpreg", ";", "}" ]

[ "@brief", "Adjusts", "the", "Internal", "High", "Speed", "oscillator", "(", "HSI", ")", "calibration", "value", "." ]

[ "/* Check the parameters */", "/* Clear HSITRIM[4:0] bits */", "/* Set the HSITRIM[4:0] bits according to HSICalibrationValue value */", "/* Store the new value */" ]

[ { "param": "HSICalibrationValue", "type": "uint8_t" } ]

[ "MIT" ]

[ "@brief", "Returns", "the", "frequencies", "of", "the", "System", "AHB", "and", "APB", "busses", "clocks", ".", "@note", "The", "frequency", "returned", "by", "this", "function", "is", "not", "the", "real", "frequency", "in", "the", "chip", ".", "It", "is", "calculated", "based", "on", "the", "predefined", "constant", "and", "the", "source", "selected", "by", "RCC_SYSCLKConfig", "()", ".", "@note", "If", "SYSCLK", "source", "is", "MSI", "function", "returns", "values", "based", "on", "MSI", "Value", "as", "defined", "by", "the", "MSI", "range", "refer", "to", "RCC_MSIRangeConfig", "()", "@note", "If", "SYSCLK", "source", "is", "HSI", "function", "returns", "values", "based", "on", "HSI_VALUE", "(", "*", ")", "@note", "If", "SYSCLK", "source", "is", "HSE", "function", "returns", "values", "based", "on", "HSE_VALUE", "(", "**", ")", "@note", "If", "SYSCLK", "source", "is", "PLL", "function", "returns", "values", "based", "on", "HSE_VALUE", "(", "**", ")", "or", "HSI_VALUE", "(", "*", ")", "multiplied", "/", "divided", "by", "the", "PLL", "factors", ".", "(", "*", ")", "HSI_VALUE", "is", "a", "constant", "defined", "in", "stm32l1xx", ".", "h", "file", "(", "default", "value", "16", "MHz", ")", "but", "the", "real", "value", "may", "vary", "depending", "on", "the", "variations", "in", "voltage", "and", "temperature", "refer", "to", "RCC_AdjustHSICalibrationValue", "()", ".", "(", "**", ")", "HSE_VALUE", "is", "a", "constant", "defined", "in", "stm32l1xx", ".", "h", "file", "(", "default", "value", "8", "MHz", ")", "user", "has", "to", "ensure", "that", "HSE_VALUE", "is", "same", "as", "the", "real", "frequency", "of", "the", "crystal", "used", ".", "Otherwise", "this", "function", "may", "return", "wrong", "result", ".", "-", "The", "result", "of", "this", "function", "could", "be", "not", "correct", "when", "using", "fractional", "value", "for", "HSE", "crystal", ".", "@param", "RCC_Clocks", ":", "pointer", "to", "a", "RCC_ClocksTypeDef", "structure", "which", "will", "hold", "the", "clocks", "frequencies", ".", "@note", "This", "function", "can", "be", "used", "by", "the", "user", "application", "to", "compute", "the", "baudrate", "for", "the", "communication", "peripherals", "or", "configure", "other", "parameters", ".", "@note", "Each", "time", "SYSCLK", "HCLK", "PCLK1", "and", "/", "or", "PCLK2", "clock", "changes", "this", "function", "must", "be", "called", "to", "update", "the", "structure", "'", "s", "field", ".", "Otherwise", "any", "configuration", "based", "on", "this", "function", "will", "be", "incorrect", ".", "@retval", "None" ]

[ "void", "RCC_GetClocksFreq", "(", "RCC_ClocksTypeDef", "*", "RCC_Clocks", ")", "{", "uint32_t", "tmp", "=", "0", ",", "pllmul", "=", "0", ",", "plldiv", "=", "0", ",", "pllsource", "=", "0", ",", "presc", "=", "0", ",", "msirange", "=", "0", ";", "tmp", "=", "RCC", "->", "CFGR", "&", "RCC_CFGR_SWS", ";", "switch", "(", "tmp", ")", "{", "case", "0x00", ":", "msirange", "=", "(", "RCC", "->", "ICSCR", "&", "RCC_ICSCR_MSIRANGE", ")", ">>", "13", ";", "RCC_Clocks", "->", "SYSCLK_Frequency", "=", "(", "32768", "*", "(", "1", "<<", "(", "msirange", "+", "1", ")", ")", ")", ";", "break", ";", "case", "0x04", ":", "RCC_Clocks", "->", "SYSCLK_Frequency", "=", "HSI_VALUE", ";", "break", ";", "case", "0x08", ":", "RCC_Clocks", "->", "SYSCLK_Frequency", "=", "HSE_VALUE", ";", "break", ";", "case", "0x0C", ":", "pllmul", "=", "RCC", "->", "CFGR", "&", "RCC_CFGR_PLLMUL", ";", "plldiv", "=", "RCC", "->", "CFGR", "&", "RCC_CFGR_PLLDIV", ";", "pllmul", "=", "PLLMulTable", "[", "(", "pllmul", ">>", "18", ")", "]", ";", "plldiv", "=", "(", "plldiv", ">>", "22", ")", "+", "1", ";", "pllsource", "=", "RCC", "->", "CFGR", "&", "RCC_CFGR_PLLSRC", ";", "if", "(", "pllsource", "==", "0x00", ")", "{", "RCC_Clocks", "->", "SYSCLK_Frequency", "=", "(", "(", "(", "HSI_VALUE", ")", "*", "pllmul", ")", "/", "plldiv", ")", ";", "}", "else", "{", "RCC_Clocks", "->", "SYSCLK_Frequency", "=", "(", "(", "(", "HSE_VALUE", ")", "*", "pllmul", ")", "/", "plldiv", ")", ";", "}", "break", ";", "default", ":", "msirange", "=", "(", "RCC", "->", "ICSCR", "&", "RCC_ICSCR_MSIRANGE", ")", ">>", "13", ";", "RCC_Clocks", "->", "SYSCLK_Frequency", "=", "(", "32768", "*", "(", "1", "<<", "(", "msirange", "+", "1", ")", ")", ")", ";", "break", ";", "}", "tmp", "=", "RCC", "->", "CFGR", "&", "RCC_CFGR_HPRE", ";", "tmp", "=", "tmp", ">>", "4", ";", "presc", "=", "APBAHBPrescTable", "[", "tmp", "]", ";", "RCC_Clocks", "->", "HCLK_Frequency", "=", "RCC_Clocks", "->", "SYSCLK_Frequency", ">>", "presc", ";", "tmp", "=", "RCC", "->", "CFGR", "&", "RCC_CFGR_PPRE1", ";", "tmp", "=", "tmp", ">>", "8", ";", "presc", "=", "APBAHBPrescTable", "[", "tmp", "]", ";", "RCC_Clocks", "->", "PCLK1_Frequency", "=", "RCC_Clocks", "->", "HCLK_Frequency", ">>", "presc", ";", "tmp", "=", "RCC", "->", "CFGR", "&", "RCC_CFGR_PPRE2", ";", "tmp", "=", "tmp", ">>", "11", ";", "presc", "=", "APBAHBPrescTable", "[", "tmp", "]", ";", "RCC_Clocks", "->", "PCLK2_Frequency", "=", "RCC_Clocks", "->", "HCLK_Frequency", ">>", "presc", ";", "}" ]

[ "@brief", "Returns", "the", "frequencies", "of", "the", "System", "AHB", "and", "APB", "busses", "clocks", "." ]

[ "/* Get SYSCLK source -------------------------------------------------------*/", "/* MSI used as system clock */", "/* HSI used as system clock */", "/* HSE used as system clock */", "/* PLL used as system clock */", "/* Get PLL clock source and multiplication factor ----------------------*/", "/* HSI oscillator clock selected as PLL clock source */", "/* HSE selected as PLL clock source */", "/* MSI used as system clock */", "/* Compute HCLK, PCLK1, PCLK2 and ADCCLK clocks frequencies ----------------*/", "/* Get HCLK prescaler */", "/* HCLK clock frequency */", "/* Get PCLK1 prescaler */", "/* PCLK1 clock frequency */", "/* Get PCLK2 prescaler */", "/* PCLK2 clock frequency */" ]

[ { "param": "RCC_Clocks", "type": "RCC_ClocksTypeDef" } ]

[ "MIT" ]

[ "@brief", "Configures", "the", "RTC", "and", "LCD", "clock", "(", "RTCCLK", "/", "LCDCLK", ")", ".", "@note", "As", "the", "RTC", "clock", "configuration", "bits", "are", "in", "the", "RTC", "domain", "and", "write", "access", "is", "denied", "to", "this", "domain", "after", "reset", "you", "have", "to", "enable", "write", "access", "using", "PWR_RTCAccessCmd", "(", "ENABLE", ")", "function", "before", "to", "configure", "the", "RTC", "clock", "source", "(", "to", "be", "done", "once", "after", "reset", ")", ".", "@note", "Once", "the", "RTC", "clock", "is", "configured", "it", "can", "'", "t", "be", "changed", "unless", "the", "RTC", "is", "reset", "using", "RCC_RTCResetCmd", "function", "or", "by", "a", "Power", "On", "Reset", "(", "POR", ")", "@note", "The", "RTC", "clock", "(", "RTCCLK", ")", "is", "used", "also", "to", "clock", "the", "LCD", "(", "LCDCLK", ")", ".", "@param", "RCC_RTCCLKSource", ":", "specifies", "the", "RTC", "clock", "source", ".", "@note", "If", "the", "LSE", "or", "LSI", "is", "used", "as", "RTC", "clock", "source", "the", "RTC", "continues", "to", "work", "in", "STOP", "and", "STANDBY", "modes", "and", "can", "be", "used", "as", "wakeup", "source", ".", "However", "when", "the", "HSE", "clock", "is", "used", "as", "RTC", "clock", "source", "the", "RTC", "cannot", "be", "used", "in", "STOP", "and", "STANDBY", "modes", ".", "@note", "The", "maximum", "input", "clock", "frequency", "for", "RTC", "is", "1MHz", "(", "when", "using", "HSE", "as", "RTC", "clock", "source", ")", ".", "@retval", "None" ]

[ "void", "RCC_RTCCLKConfig", "(", "uint32_t", "RCC_RTCCLKSource", ")", "{", "uint32_t", "tmpreg", "=", "0", ";", "assert_param", "(", "IS_RCC_RTCCLK_SOURCE", "(", "RCC_RTCCLKSource", ")", ")", ";", "if", "(", "(", "RCC_RTCCLKSource", "&", "RCC_CSR_RTCSEL_HSE", ")", "==", "RCC_CSR_RTCSEL_HSE", ")", "{", "tmpreg", "=", "RCC", "->", "CR", ";", "tmpreg", "&=", "~", "RCC_CR_RTCPRE", ";", "tmpreg", "|=", "(", "RCC_RTCCLKSource", "&", "RCC_CR_RTCPRE", ")", ";", "RCC", "->", "CR", "=", "tmpreg", ";", "}", "RCC", "->", "CSR", "&=", "~", "RCC_CSR_RTCSEL", ";", "RCC", "->", "CSR", "|=", "(", "RCC_RTCCLKSource", "&", "RCC_CSR_RTCSEL", ")", ";", "}" ]

[ "@brief", "Configures", "the", "RTC", "and", "LCD", "clock", "(", "RTCCLK", "/", "LCDCLK", ")", "." ]

[ "/* Check the parameters */", "/* If HSE is selected as RTC clock source, configure HSE division factor for RTC clock */", "/* Clear RTCPRE[1:0] bits */", "/* Configure HSE division factor for RTC clock */", "/* Store the new value */", "/* Select the RTC clock source */" ]

[ { "param": "RCC_RTCCLKSource", "type": "uint32_t" } ]

[ "MIT" ]

[ "@brief", "Forces", "or", "releases", "AHB", "peripheral", "reset", ".", "@param", "RCC_AHBPeriph", ":", "specifies", "the", "AHB", "peripheral", "to", "reset", "." ]

[ "void", "RCC_AHBPeriphResetCmd", "(", "uint32_t", "RCC_AHBPeriph", ",", "FunctionalState", "NewState", ")", "{", "assert_param", "(", "IS_RCC_AHB_PERIPH", "(", "RCC_AHBPeriph", ")", ")", ";", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "if", "(", "NewState", "!=", "DISABLE", ")", "{", "RCC", "->", "AHBRSTR", "|=", "RCC_AHBPeriph", ";", "}", "else", "{", "RCC", "->", "AHBRSTR", "&=", "~", "RCC_AHBPeriph", ";", "}", "}" ]

[ "@brief", "Forces", "or", "releases", "AHB", "peripheral", "reset", "." ]

[ "/* Check the parameters */" ]

[ { "param": "RCC_AHBPeriph", "type": "uint32_t" }, { "param": "NewState", "type": "FunctionalState" } ]

[ "MIT" ]

[ "@brief", "Enables", "or", "disables", "the", "AHB", "peripheral", "clock", "during", "SLEEP", "mode", ".", "@note", "Peripheral", "clock", "gating", "in", "SLEEP", "mode", "can", "be", "used", "to", "further", "reduce", "power", "consumption", ".", "-", "After", "wakeup", "from", "SLEEP", "mode", "the", "peripheral", "clock", "is", "enabled", "again", ".", "-", "By", "default", "all", "peripheral", "clocks", "are", "enabled", "during", "SLEEP", "mode", ".", "@param", "RCC_AHBPeriph", ":", "specifies", "the", "AHB", "peripheral", "to", "gates", "its", "clock", "." ]

[ "void", "RCC_AHBPeriphClockLPModeCmd", "(", "uint32_t", "RCC_AHBPeriph", ",", "FunctionalState", "NewState", ")", "{", "assert_param", "(", "IS_RCC_AHB_LPMODE_PERIPH", "(", "RCC_AHBPeriph", ")", ")", ";", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "if", "(", "NewState", "!=", "DISABLE", ")", "{", "RCC", "->", "AHBLPENR", "|=", "RCC_AHBPeriph", ";", "}", "else", "{", "RCC", "->", "AHBLPENR", "&=", "~", "RCC_AHBPeriph", ";", "}", "}" ]

[ "@brief", "Enables", "or", "disables", "the", "AHB", "peripheral", "clock", "during", "SLEEP", "mode", "." ]

[ "/* Check the parameters */" ]

[ { "param": "RCC_AHBPeriph", "type": "uint32_t" }, { "param": "NewState", "type": "FunctionalState" } ]

[ "MIT" ]

[ "@brief", "Checks", "whether", "the", "specified", "RCC", "flag", "is", "set", "or", "not", ".", "@param", "RCC_FLAG", ":", "specifies", "the", "flag", "to", "check", "." ]

[ "FlagStatus", "RCC_GetFlagStatus", "(", "uint8_t", "RCC_FLAG", ")", "{", "uint32_t", "tmp", "=", "0", ";", "uint32_t", "statusreg", "=", "0", ";", "FlagStatus", "bitstatus", "=", "RESET", ";", "assert_param", "(", "IS_RCC_FLAG", "(", "RCC_FLAG", ")", ")", ";", "tmp", "=", "RCC_FLAG", ">>", "5", ";", "if", "(", "tmp", "==", "1", ")", "{", "statusreg", "=", "RCC", "->", "CR", ";", "}", "else", "{", "statusreg", "=", "RCC", "->", "CSR", ";", "}", "tmp", "=", "RCC_FLAG", "&", "FLAG_MASK", ";", "if", "(", "(", "statusreg", "&", "(", "(", "uint32_t", ")", "1", "<<", "tmp", ")", ")", "!=", "(", "uint32_t", ")", "RESET", ")", "{", "bitstatus", "=", "SET", ";", "}", "else", "{", "bitstatus", "=", "RESET", ";", "}", "return", "bitstatus", ";", "}" ]

[ "@brief", "Checks", "whether", "the", "specified", "RCC", "flag", "is", "set", "or", "not", "." ]

[ "/* Check the parameters */", "/* Get the RCC register index */", "/* The flag to check is in CR register */", "/* The flag to check is in CSR register (tmp == 2) */", "/* Get the flag position */", "/* Return the flag status */" ]

[ { "param": "RCC_FLAG", "type": "uint8_t" } ]

[ "MIT" ]

[ "@brief", "Deinitializes", "the", "DMAy", "Channelx", "registers", "to", "their", "default", "reset", "values", ".", "@param", "DMAy_Channelx", ":", "where", "y", "can", "be", "1", "or", "2", "to", "select", "the", "DMA", "and", "x", "can", "be", "1", "to", "7", "for", "DMA1", "and", "1", "to", "5", "for", "DMA2", "to", "select", "the", "DMA", "Channel", ".", "@retval", "None" ]

[ "void", "DMA_DeInit", "(", "DMA_Channel_TypeDef", "*", "DMAy_Channelx", ")", "{", "assert_param", "(", "IS_DMA_ALL_PERIPH", "(", "DMAy_Channelx", ")", ")", ";", "DMAy_Channelx", "->", "CCR", "&=", "(", "uint16_t", ")", "(", "~", "DMA_CCR1_EN", ")", ";", "DMAy_Channelx", "->", "CCR", "=", "0", ";", "DMAy_Channelx", "->", "CNDTR", "=", "0", ";", "DMAy_Channelx", "->", "CPAR", "=", "0", ";", "DMAy_Channelx", "->", "CMAR", "=", "0", ";", "if", "(", "DMAy_Channelx", "==", "DMA1_Channel1", ")", "{", "DMA1", "->", "IFCR", "|=", "DMA1_CHANNEL1_IT_MASK", ";", "}", "else", "if", "(", "DMAy_Channelx", "==", "DMA1_Channel2", ")", "{", "DMA1", "->", "IFCR", "|=", "DMA1_CHANNEL2_IT_MASK", ";", "}", "else", "if", "(", "DMAy_Channelx", "==", "DMA1_Channel3", ")", "{", "DMA1", "->", "IFCR", "|=", "DMA1_CHANNEL3_IT_MASK", ";", "}", "else", "if", "(", "DMAy_Channelx", "==", "DMA1_Channel4", ")", "{", "DMA1", "->", "IFCR", "|=", "DMA1_CHANNEL4_IT_MASK", ";", "}", "else", "if", "(", "DMAy_Channelx", "==", "DMA1_Channel5", ")", "{", "DMA1", "->", "IFCR", "|=", "DMA1_CHANNEL5_IT_MASK", ";", "}", "else", "if", "(", "DMAy_Channelx", "==", "DMA1_Channel6", ")", "{", "DMA1", "->", "IFCR", "|=", "DMA1_CHANNEL6_IT_MASK", ";", "}", "else", "if", "(", "DMAy_Channelx", "==", "DMA1_Channel7", ")", "{", "DMA1", "->", "IFCR", "|=", "DMA1_CHANNEL7_IT_MASK", ";", "}", "else", "if", "(", "DMAy_Channelx", "==", "DMA2_Channel1", ")", "{", "DMA2", "->", "IFCR", "|=", "DMA2_CHANNEL1_IT_MASK", ";", "}", "else", "if", "(", "DMAy_Channelx", "==", "DMA2_Channel2", ")", "{", "DMA2", "->", "IFCR", "|=", "DMA2_CHANNEL2_IT_MASK", ";", "}", "else", "if", "(", "DMAy_Channelx", "==", "DMA2_Channel3", ")", "{", "DMA2", "->", "IFCR", "|=", "DMA2_CHANNEL3_IT_MASK", ";", "}", "else", "if", "(", "DMAy_Channelx", "==", "DMA2_Channel4", ")", "{", "DMA2", "->", "IFCR", "|=", "DMA2_CHANNEL4_IT_MASK", ";", "}", "else", "{", "if", "(", "DMAy_Channelx", "==", "DMA2_Channel5", ")", "{", "DMA2", "->", "IFCR", "|=", "DMA2_CHANNEL5_IT_MASK", ";", "}", "}", "}" ]

[ "@brief", "Deinitializes", "the", "DMAy", "Channelx", "registers", "to", "their", "default", "reset", "values", "." ]

[ "/* Check the parameters */", "/* Disable the selected DMAy Channelx */", "/* Reset DMAy Channelx control register */", "/* Reset DMAy Channelx remaining bytes register */", "/* Reset DMAy Channelx peripheral address register */", "/* Reset DMAy Channelx memory address register */", "/* Reset interrupt pending bits for DMA1 Channel1 */", "/* Reset interrupt pending bits for DMA1 Channel2 */", "/* Reset interrupt pending bits for DMA1 Channel3 */", "/* Reset interrupt pending bits for DMA1 Channel4 */", "/* Reset interrupt pending bits for DMA1 Channel5 */", "/* Reset interrupt pending bits for DMA1 Channel6 */", "/* Reset interrupt pending bits for DMA1 Channel7 */", "/* Reset interrupt pending bits for DMA2 Channel1 */", "/* Reset interrupt pending bits for DMA2 Channel2 */", "/* Reset interrupt pending bits for DMA2 Channel3 */", "/* Reset interrupt pending bits for DMA2 Channel4 */", "/* Reset interrupt pending bits for DMA2 Channel5 */" ]

[ { "param": "DMAy_Channelx", "type": "DMA_Channel_TypeDef" } ]

[ "MIT" ]

[ "@brief", "Initializes", "the", "DMAy", "Channelx", "according", "to", "the", "specified", "parameters", "in", "the", "DMA_InitStruct", ".", "@param", "DMAy_Channelx", ":", "where", "y", "can", "be", "1", "or", "2", "to", "select", "the", "DMA", "and", "x", "can", "be", "1", "to", "7", "for", "DMA1", "and", "1", "to", "5", "for", "DMA2", "to", "select", "the", "DMA", "Channel", ".", "@param", "DMA_InitStruct", ":", "pointer", "to", "a", "DMA_InitTypeDef", "structure", "that", "contains", "the", "configuration", "information", "for", "the", "specified", "DMA", "Channel", ".", "@retval", "None" ]

[ "void", "DMA_Init", "(", "DMA_Channel_TypeDef", "*", "DMAy_Channelx", ",", "DMA_InitTypeDef", "*", "DMA_InitStruct", ")", "{", "uint32_t", "tmpreg", "=", "0", ";", "assert_param", "(", "IS_DMA_ALL_PERIPH", "(", "DMAy_Channelx", ")", ")", ";", "assert_param", "(", "IS_DMA_DIR", "(", "DMA_InitStruct", "->", "DMA_DIR", ")", ")", ";", "assert_param", "(", "IS_DMA_BUFFER_SIZE", "(", "DMA_InitStruct", "->", "DMA_BufferSize", ")", ")", ";", "assert_param", "(", "IS_DMA_PERIPHERAL_INC_STATE", "(", "DMA_InitStruct", "->", "DMA_PeripheralInc", ")", ")", ";", "assert_param", "(", "IS_DMA_MEMORY_INC_STATE", "(", "DMA_InitStruct", "->", "DMA_MemoryInc", ")", ")", ";", "assert_param", "(", "IS_DMA_PERIPHERAL_DATA_SIZE", "(", "DMA_InitStruct", "->", "DMA_PeripheralDataSize", ")", ")", ";", "assert_param", "(", "IS_DMA_MEMORY_DATA_SIZE", "(", "DMA_InitStruct", "->", "DMA_MemoryDataSize", ")", ")", ";", "assert_param", "(", "IS_DMA_MODE", "(", "DMA_InitStruct", "->", "DMA_Mode", ")", ")", ";", "assert_param", "(", "IS_DMA_PRIORITY", "(", "DMA_InitStruct", "->", "DMA_Priority", ")", ")", ";", "assert_param", "(", "IS_DMA_M2M_STATE", "(", "DMA_InitStruct", "->", "DMA_M2M", ")", ")", ";", "tmpreg", "=", "DMAy_Channelx", "->", "CCR", ";", "tmpreg", "&=", "CCR_CLEAR_MASK", ";", "tmpreg", "|=", "DMA_InitStruct", "->", "DMA_DIR", "|", "DMA_InitStruct", "->", "DMA_Mode", "|", "DMA_InitStruct", "->", "DMA_PeripheralInc", "|", "DMA_InitStruct", "->", "DMA_MemoryInc", "|", "DMA_InitStruct", "->", "DMA_PeripheralDataSize", "|", "DMA_InitStruct", "->", "DMA_MemoryDataSize", "|", "DMA_InitStruct", "->", "DMA_Priority", "|", "DMA_InitStruct", "->", "DMA_M2M", ";", "DMAy_Channelx", "->", "CCR", "=", "tmpreg", ";", "DMAy_Channelx", "->", "CNDTR", "=", "DMA_InitStruct", "->", "DMA_BufferSize", ";", "DMAy_Channelx", "->", "CPAR", "=", "DMA_InitStruct", "->", "DMA_PeripheralBaseAddr", ";", "DMAy_Channelx", "->", "CMAR", "=", "DMA_InitStruct", "->", "DMA_MemoryBaseAddr", ";", "}" ]

[ "@brief", "Initializes", "the", "DMAy", "Channelx", "according", "to", "the", "specified", "parameters", "in", "the", "DMA_InitStruct", "." ]

[ "/* Check the parameters */", "/*--------------------------- DMAy Channelx CCR Configuration -----------------*/", "/* Get the DMAy_Channelx CCR value */", "/* Clear MEM2MEM, PL, MSIZE, PSIZE, MINC, PINC, CIRC and DIR bits */", "/* Configure DMAy Channelx: data transfer, data size, priority level and mode */", "/* Set DIR bit according to DMA_DIR value */", "/* Set CIRC bit according to DMA_Mode value */", "/* Set PINC bit according to DMA_PeripheralInc value */", "/* Set MINC bit according to DMA_MemoryInc value */", "/* Set PSIZE bits according to DMA_PeripheralDataSize value */", "/* Set MSIZE bits according to DMA_MemoryDataSize value */", "/* Set PL bits according to DMA_Priority value */", "/* Set the MEM2MEM bit according to DMA_M2M value */", "/* Write to DMAy Channelx CCR */", "/*--------------------------- DMAy Channelx CNDTR Configuration ---------------*/", "/* Write to DMAy Channelx CNDTR */", "/*--------------------------- DMAy Channelx CPAR Configuration ----------------*/", "/* Write to DMAy Channelx CPAR */", "/*--------------------------- DMAy Channelx CMAR Configuration ----------------*/", "/* Write to DMAy Channelx CMAR */" ]

[ { "param": "DMAy_Channelx", "type": "DMA_Channel_TypeDef" }, { "param": "DMA_InitStruct", "type": "DMA_InitTypeDef" } ]

[ "MIT" ]

[ "@brief", "Enables", "or", "disables", "the", "read", "out", "protection", ".", "@note", "To", "correctly", "run", "this", "function", "the", "FLASH_OB_Unlock", "()", "function", "must", "be", "called", "before", ".", "Call", "the", "FLASH_OB_Lock", "()", "to", "disable", "the", "flash", "control", "register", "access", "and", "the", "option", "bytes", "(", "recommended", "to", "protect", "the", "FLASH", "memory", "against", "possible", "unwanted", "operation", ")", ".", "@param", "FLASH_ReadProtection_Level", ":", "specifies", "the", "read", "protection", "level", "." ]

[ "FLASH_Status", "FLASH_OB_RDPConfig", "(", "uint8_t", "OB_RDP", ")", "{", "FLASH_Status", "status", "=", "FLASH_COMPLETE", ";", "uint8_t", "tmp1", "=", "0", ";", "uint32_t", "tmp2", "=", "0", ";", "assert_param", "(", "IS_OB_RDP", "(", "OB_RDP", ")", ")", ";", "status", "=", "FLASH_WaitForLastOperation", "(", "FLASH_ER_PRG_TIMEOUT", ")", ";", "tmp1", "=", "(", "uint8_t", ")", "(", "~", "(", "OB_RDP", ")", ")", ";", "tmp2", "=", "(", "uint32_t", ")", "(", "(", "(", "uint32_t", ")", "(", "(", "uint32_t", ")", "(", "tmp1", ")", "<<", "16", ")", ")", "|", "(", "(", "uint32_t", ")", "OB_RDP", ")", ")", ";", "if", "(", "status", "==", "FLASH_COMPLETE", ")", "{", "OB", "->", "RDP", "=", "tmp2", ";", "}", "status", "=", "FLASH_WaitForLastOperation", "(", "FLASH_ER_PRG_TIMEOUT", ")", ";", "return", "status", ";", "}" ]

[ "@brief", "Enables", "or", "disables", "the", "read", "out", "protection", "." ]

[ "/* Check the parameters */", "/* calculate the option byte to write */", "/* program read protection level */", "/* Wait for last operation to be completed */", "/* Return the Read protection operation Status */" ]

[ { "param": "OB_RDP", "type": "uint8_t" } ]

[ "MIT" ]

[ "@brief", "Programs", "the", "FLASH", "User", "Option", "Byte", ":", "IWDG_SW", "/", "RST_STOP", "/", "RST_STDBY", ".", "@note", "To", "correctly", "run", "this", "function", "the", "FLASH_OB_Unlock", "()", "function", "must", "be", "called", "before", ".", "Call", "the", "FLASH_OB_Lock", "()", "to", "disable", "the", "flash", "control", "register", "access", "and", "the", "option", "bytes", "(", "recommended", "to", "protect", "the", "FLASH", "memory", "against", "possible", "unwanted", "operation", ")", ".", "@param", "OB_IWDG", ":", "Selects", "the", "WDG", "mode", ".", "This", "parameter", "can", "be", "one", "of", "the", "following", "values", ":", "@arg", "OB_IWDG_SW", ":", "Software", "WDG", "selected", "@arg", "OB_IWDG_HW", ":", "Hardware", "WDG", "selected", "@param", "OB_STOP", ":", "Reset", "event", "when", "entering", "STOP", "mode", ".", "This", "parameter", "can", "be", "one", "of", "the", "following", "values", ":", "@arg", "OB_STOP_NoRST", ":", "No", "reset", "generated", "when", "entering", "in", "STOP", "@arg", "OB_STOP_RST", ":", "Reset", "generated", "when", "entering", "in", "STOP", "@param", "OB_STDBY", ":", "Reset", "event", "when", "entering", "Standby", "mode", "." ]

[ "FLASH_Status", "FLASH_OB_UserConfig", "(", "uint8_t", "OB_IWDG", ",", "uint8_t", "OB_STOP", ",", "uint8_t", "OB_STDBY", ")", "{", "FLASH_Status", "status", "=", "FLASH_COMPLETE", ";", "uint32_t", "tmp", "=", "0", ",", "tmp1", "=", "0", ";", "assert_param", "(", "IS_OB_IWDG_SOURCE", "(", "OB_IWDG", ")", ")", ";", "assert_param", "(", "IS_OB_STOP_SOURCE", "(", "OB_STOP", ")", ")", ";", "assert_param", "(", "IS_OB_STDBY_SOURCE", "(", "OB_STDBY", ")", ")", ";", "tmp1", "=", "(", "FLASH", "->", "OBR", "&", "0x000F0000", ")", ">>", "16", ";", "tmp", "=", "(", "uint32_t", ")", "(", "(", "(", "uint32_t", ")", "~", "(", "(", "uint32_t", ")", "(", "(", "uint32_t", ")", "(", "OB_IWDG", ")", "|", "(", "uint32_t", ")", "(", "OB_STOP", ")", "|", "(", "uint32_t", ")", "(", "OB_STDBY", ")", "|", "tmp1", ")", ")", ")", "<<", "(", "(", "uint32_t", ")", "0x10", ")", ")", ";", "tmp", "|=", "(", "(", "uint32_t", ")", "(", "OB_IWDG", ")", "|", "(", "(", "uint32_t", ")", "OB_STOP", ")", "|", "(", "uint32_t", ")", "(", "OB_STDBY", ")", "|", "tmp1", ")", ";", "status", "=", "FLASH_WaitForLastOperation", "(", "FLASH_ER_PRG_TIMEOUT", ")", ";", "if", "(", "status", "==", "FLASH_COMPLETE", ")", "{", "OB", "->", "USER", "=", "tmp", ";", "}", "status", "=", "FLASH_WaitForLastOperation", "(", "FLASH_ER_PRG_TIMEOUT", ")", ";", "return", "status", ";", "}" ]

[ "@brief", "Programs", "the", "FLASH", "User", "Option", "Byte", ":", "IWDG_SW", "/", "RST_STOP", "/", "RST_STDBY", "." ]

[ "/* Check the parameters */", "/* Get the User Option byte register */", "/* Calculate the user option byte to write */", "/* Wait for last operation to be completed */", "/* Write the User Option Byte */", "/* Wait for last operation to be completed */", "/* Return the Option Byte program Status */" ]

[ { "param": "OB_IWDG", "type": "uint8_t" }, { "param": "OB_STOP", "type": "uint8_t" }, { "param": "OB_STDBY", "type": "uint8_t" } ]

[ "MIT" ]

[ "@param", "data", "A", "thread_state", "object", ".", "@param", "user_data", "User", "data", "to", "pass", "to", "thread_state", "callback", "Small", "wrapper", "function", "that", "is", "internally", "used", "to", "pass", "a", "job", "to", "a", "worker", "." ]

[ "static", "void", "rofi_view_call_thread", "(", "gpointer", "data", ",", "gpointer", "user_data", ")", "{", "thread_state", "*", "t", "=", "(", "thread_state", "*", ")", "data", ";", "t", "->", "callback", "(", "t", ",", "user_data", ")", ";", "}" ]

[ "@param", "data", "A", "thread_state", "object", "." ]

[]

[ { "param": "data", "type": "gpointer" }, { "param": "user_data", "type": "gpointer" } ]

[ "MIT" ]

[ "@param", "state", "Internal", "state", "of", "the", "menu", ".", "Calculate", "the", "width", "of", "the", "window", "and", "the", "width", "of", "an", "element", "." ]

[ "static", "void", "rofi_view_calculate_window_width", "(", "RofiViewState", "*", "state", ")", "{", "if", "(", "CacheState", ".", "fullscreen", ")", "{", "state", "->", "width", "=", "CacheState", ".", "mon", ".", "w", ";", "return", ";", "}", "if", "(", "config", ".", "menu_width", "<", "0", ")", "{", "double", "fw", "=", "textbox_get_estimated_char_width", "(", ")", ";", "state", "->", "width", "=", "-", "(", "fw", "*", "config", ".", "menu_width", ")", ";", "state", "->", "width", "+=", "widget_padding_get_padding_width", "(", "WIDGET", "(", "state", "->", "main_window", ")", ")", ";", "}", "else", "{", "state", "->", "width", "=", "config", ".", "menu_width", "<", "101", "?", "(", "CacheState", ".", "mon", ".", "w", "/", "100.0f", ")", "*", "(", "float", ")", "config", ".", "menu_width", ":", "config", ".", "menu_width", ";", "}", "RofiDistance", "width", "=", "rofi_theme_get_distance", "(", "WIDGET", "(", "state", "->", "main_window", ")", ",", "\"", "\"", ",", "state", "->", "width", ")", ";", "state", "->", "width", "=", "distance_get_pixel", "(", "width", ",", "ROFI_ORIENTATION_HORIZONTAL", ")", ";", "}" ]

[ "@param", "state", "Internal", "state", "of", "the", "menu", "." ]

[ "// Calculate as float to stop silly, big rounding down errors.", "// Use theme configured width, if set." ]

[ { "param": "state", "type": "RofiViewState" } ]

[ "MIT" ]

[ "@param", "state", "The", "current", "RofiViewState", "Tab", "handling", "." ]

[ "static", "void", "rofi_view_nav_row_tab", "(", "RofiViewState", "*", "state", ")", "{", "if", "(", "state", "->", "filtered_lines", "==", "1", ")", "{", "state", "->", "retv", "=", "MENU_OK", ";", "(", "state", "->", "selected_line", ")", "=", "state", "->", "line_map", "[", "listview_get_selected", "(", "state", "->", "list_view", ")", "]", ";", "state", "->", "quit", "=", "1", ";", "return", ";", "}", "if", "(", "state", "->", "filtered_lines", "==", "0", "&&", "ROW_TAB", "==", "state", "->", "prev_action", ")", "{", "state", "->", "retv", "=", "MENU_NEXT", ";", "(", "state", "->", "selected_line", ")", "=", "0", ";", "state", "->", "quit", "=", "TRUE", ";", "}", "else", "{", "listview_nav_down", "(", "state", "->", "list_view", ")", ";", "}", "state", "->", "prev_action", "=", "ROW_TAB", ";", "}" ]

[ "@param", "state", "The", "current", "RofiViewState", "Tab", "handling", "." ]

[ "// Double tab!" ]

[ { "param": "state", "type": "RofiViewState" } ]

[ "MIT" ]

[ "@param", "state", "The", "current", "RofiViewState", "complete", "current", "row", "." ]

[ "inline", "static", "void", "rofi_view_nav_row_select", "(", "RofiViewState", "*", "state", ")", "{", "if", "(", "state", "->", "list_view", "==", "NULL", ")", "{", "return", ";", "}", "unsigned", "int", "selected", "=", "listview_get_selected", "(", "state", "->", "list_view", ")", ";", "if", "(", "selected", "<", "state", "->", "filtered_lines", ")", "{", "char", "*", "str", "=", "mode_get_completion", "(", "state", "->", "sw", ",", "state", "->", "line_map", "[", "selected", "]", ")", ";", "textbox_text", "(", "state", "->", "text", ",", "str", ")", ";", "g_free", "(", "str", ")", ";", "textbox_keybinding", "(", "state", "->", "text", ",", "MOVE_END", ")", ";", "state", "->", "refilter", "=", "TRUE", ";", "}", "}" ]

[ "@param", "state", "The", "current", "RofiViewState", "complete", "current", "row", "." ]

[ "// If a valid item is selected, return that.." ]

[ { "param": "state", "type": "RofiViewState" } ]

[ "MIT" ]

[ "@param", "state", "The", "current", "RofiViewState", "Move", "the", "selection", "to", "first", "row", "." ]

[ "inline", "static", "void", "rofi_view_nav_first", "(", "RofiViewState", "*", "state", ")", "{", "listview_set_selected", "(", "state", "->", "list_view", ",", "0", ")", ";", "}" ]

[ "@param", "state", "The", "current", "RofiViewState", "Move", "the", "selection", "to", "first", "row", "." ]

[ "// state->selected = 0;" ]

[ { "param": "state", "type": "RofiViewState" } ]

[ "MIT" ]

[ "@param", "state", "The", "current", "RofiViewState", "Move", "the", "selection", "to", "last", "row", "." ]

[ "inline", "static", "void", "rofi_view_nav_last", "(", "RofiViewState", "*", "state", ")", "{", "if", "(", "state", "->", "filtered_lines", "==", "0", ")", "{", "return", ";", "}", "listview_set_selected", "(", "state", "->", "list_view", ",", "-1", ")", ";", "}" ]

[ "@param", "state", "The", "current", "RofiViewState", "Move", "the", "selection", "to", "last", "row", "." ]

[ "// If no lines, do nothing.", "//state->selected = state->filtered_lines - 1;" ]

[ { "param": "state", "type": "RofiViewState" } ]

[ "MIT" ]

[ "Handle", "window", "configure", "event", ".", "Handles", "resizes", "." ]

[ "void", "rofi_view_temp_configure_notify", "(", "RofiViewState", "*", "state", ",", "xcb_configure_notify_event_t", "*", "xce", ")", "{", "if", "(", "xce", "->", "window", "==", "CacheState", ".", "main_window", ")", "{", "if", "(", "state", "->", "x", "!=", "xce", "->", "x", "||", "state", "->", "y", "!=", "xce", "->", "y", ")", "{", "state", "->", "x", "=", "xce", "->", "x", ";", "state", "->", "y", "=", "xce", "->", "y", ";", "widget_queue_redraw", "(", "WIDGET", "(", "state", "->", "main_window", ")", ")", ";", "}", "if", "(", "state", "->", "width", "!=", "xce", "->", "width", "||", "state", "->", "height", "!=", "xce", "->", "height", ")", "{", "state", "->", "width", "=", "xce", "->", "width", ";", "state", "->", "height", "=", "xce", "->", "height", ";", "cairo_destroy", "(", "CacheState", ".", "edit_draw", ")", ";", "cairo_surface_destroy", "(", "CacheState", ".", "edit_surf", ")", ";", "xcb_free_pixmap", "(", "xcb", "->", "connection", ",", "CacheState", ".", "edit_pixmap", ")", ";", "CacheState", ".", "edit_pixmap", "=", "xcb_generate_id", "(", "xcb", "->", "connection", ")", ";", "xcb_create_pixmap", "(", "xcb", "->", "connection", ",", "depth", "->", "depth", ",", "CacheState", ".", "edit_pixmap", ",", "CacheState", ".", "main_window", ",", "state", "->", "width", ",", "state", "->", "height", ")", ";", "CacheState", ".", "edit_surf", "=", "cairo_xcb_surface_create", "(", "xcb", "->", "connection", ",", "CacheState", ".", "edit_pixmap", ",", "visual", ",", "state", "->", "width", ",", "state", "->", "height", ")", ";", "CacheState", ".", "edit_draw", "=", "cairo_create", "(", "CacheState", ".", "edit_surf", ")", ";", "g_debug", "(", "\"", "\"", ",", "state", "->", "width", ",", "state", "->", "height", ")", ";", "widget_resize", "(", "WIDGET", "(", "state", "->", "main_window", ")", ",", "state", "->", "width", ",", "state", "->", "height", ")", ";", "}", "}", "}" ]

[ "Handle", "window", "configure", "event", "." ]

[]

[ { "param": "state", "type": "RofiViewState" }, { "param": "xce", "type": "xcb_configure_notify_event_t" } ]

[ "MIT" ]

[ "Quit", "rofi", "on", "click", "(", "outside", "of", "view", ")" ]

[ "void", "rofi_view_temp_click_to_exit", "(", "RofiViewState", "*", "state", ",", "xcb_window_t", "target", ")", "{", "if", "(", "(", "CacheState", ".", "flags", "&", "MENU_NORMAL_WINDOW", ")", "==", "0", ")", "{", "if", "(", "target", "!=", "CacheState", ".", "main_window", ")", "{", "state", "->", "quit", "=", "TRUE", ";", "state", "->", "retv", "=", "MENU_CANCEL", ";", "}", "}", "}" ]

[ "Quit", "rofi", "on", "click", "(", "outside", "of", "view", ")" ]

[]

[ { "param": "state", "type": "RofiViewState" }, { "param": "target", "type": "xcb_window_t" } ]

[ "MIT" ]

[ "@param", "tb", "The", "textbox", "object", ".", "Update", "the", "pango", "layout", "'", "s", "text", ".", "It", "does", "this", "depending", "on", "the", "textbox", "flags", "." ]

[ "static", "void", "__textbox_update_pango_text", "(", "textbox", "*", "tb", ")", "{", "pango_layout_set_attributes", "(", "tb", "->", "layout", ",", "NULL", ")", ";", "if", "(", "(", "tb", "->", "flags", "&", "TB_PASSWORD", ")", "==", "TB_PASSWORD", ")", "{", "size_t", "l", "=", "g_utf8_strlen", "(", "tb", "->", "text", ",", "-1", ")", ";", "char", "string", "[", "l", "+", "1", "]", ";", "memset", "(", "string", ",", "'", "'", ",", "l", ")", ";", "string", "[", "l", "]", "=", "'", "\\0", "'", ";", "pango_layout_set_text", "(", "tb", "->", "layout", ",", "string", ",", "l", ")", ";", "}", "else", "if", "(", "tb", "->", "flags", "&", "TB_MARKUP", "||", "tb", "->", "tbft", "&", "MARKUP", ")", "{", "pango_layout_set_markup", "(", "tb", "->", "layout", ",", "tb", "->", "text", ",", "-1", ")", ";", "}", "else", "{", "pango_layout_set_text", "(", "tb", "->", "layout", ",", "tb", "->", "text", ",", "-1", ")", ";", "}", "}" ]

[ "@param", "tb", "The", "textbox", "object", "." ]

[]

[ { "param": "tb", "type": "textbox" } ]

[ "MIT" ]

[ "set", "the", "default", "text", "to", "display" ]

[ "void", "textbox_text", "(", "textbox", "*", "tb", ",", "const", "char", "*", "text", ")", "{", "if", "(", "tb", "==", "NULL", ")", "{", "return", ";", "}", "g_free", "(", "tb", "->", "text", ")", ";", "const", "gchar", "*", "last_pointer", "=", "NULL", ";", "if", "(", "g_utf8_validate", "(", "text", ",", "-1", ",", "&", "last_pointer", ")", ")", "{", "tb", "->", "text", "=", "g_strdup", "(", "text", ")", ";", "}", "else", "{", "if", "(", "last_pointer", "!=", "NULL", ")", "{", "tb", "->", "text", "=", "g_strndup", "(", "text", ",", "(", "last_pointer", "-", "text", ")", ")", ";", "}", "else", "{", "tb", "->", "text", "=", "g_strdup", "(", "\"", "\"", ")", ";", "}", "}", "__textbox_update_pango_text", "(", "tb", ")", ";", "if", "(", "tb", "->", "flags", "&", "TB_AUTOWIDTH", ")", "{", "textbox_moveresize", "(", "tb", ",", "tb", "->", "widget", ".", "x", ",", "tb", "->", "widget", ".", "y", ",", "tb", "->", "widget", ".", "w", ",", "tb", "->", "widget", ".", "h", ")", ";", "if", "(", "WIDGET", "(", "tb", ")", "->", "parent", ")", "{", "widget_update", "(", "WIDGET", "(", "tb", ")", "->", "parent", ")", ";", "}", "}", "tb", "->", "cursor", "=", "MAX", "(", "0", ",", "MIN", "(", "(", "int", ")", "g_utf8_strlen", "(", "tb", "->", "text", ",", "-1", ")", ",", "tb", "->", "cursor", ")", ")", ";", "widget_queue_redraw", "(", "WIDGET", "(", "tb", ")", ")", ";", "}" ]

[ "set", "the", "default", "text", "to", "display" ]

[ "// Copy string up to invalid character." ]

[ { "param": "tb", "type": "textbox" }, { "param": "text", "type": "char" } ]

[ "MIT" ]

[ "within", "the", "parent", "handled", "auto", "width", "/", "height", "modes" ]

[ "void", "textbox_moveresize", "(", "textbox", "*", "tb", ",", "int", "x", ",", "int", "y", ",", "int", "w", ",", "int", "h", ")", "{", "unsigned", "int", "offset", "=", "tb", "->", "left_offset", "*", "1.2", "+", "(", "(", "tb", "->", "flags", "&", "TB_INDICATOR", ")", "?", "DOT_OFFSET", ":", "0", ")", ";", "if", "(", "tb", "->", "flags", "&", "TB_AUTOWIDTH", ")", "{", "pango_layout_set_width", "(", "tb", "->", "layout", ",", "-1", ")", ";", "w", "=", "textbox_get_font_width", "(", "tb", ")", "+", "widget_padding_get_padding_width", "(", "WIDGET", "(", "tb", ")", ")", "+", "offset", ";", "}", "else", "{", "if", "(", "(", "tb", "->", "flags", "&", "TB_EDITABLE", ")", "==", "TB_EDITABLE", ")", "{", "pango_layout_set_ellipsize", "(", "tb", "->", "layout", ",", "PANGO_ELLIPSIZE_MIDDLE", ")", ";", "}", "else", "if", "(", "(", "tb", "->", "flags", "&", "TB_WRAP", ")", "!=", "TB_WRAP", ")", "{", "pango_layout_set_ellipsize", "(", "tb", "->", "layout", ",", "PANGO_ELLIPSIZE_END", ")", ";", "}", "}", "if", "(", "tb", "->", "flags", "&", "TB_AUTOHEIGHT", ")", "{", "int", "tw", "=", "MAX", "(", "1", ",", "w", ")", ";", "pango_layout_set_width", "(", "tb", "->", "layout", ",", "PANGO_SCALE", "*", "(", "tw", "-", "widget_padding_get_padding_width", "(", "WIDGET", "(", "tb", ")", ")", "-", "offset", ")", ")", ";", "int", "hd", "=", "textbox_get_height", "(", "tb", ")", ";", "h", "=", "MAX", "(", "hd", ",", "h", ")", ";", "}", "if", "(", "x", "!=", "tb", "->", "widget", ".", "x", "||", "y", "!=", "tb", "->", "widget", ".", "y", "||", "w", "!=", "tb", "->", "widget", ".", "w", "||", "h", "!=", "tb", "->", "widget", ".", "h", ")", "{", "tb", "->", "widget", ".", "x", "=", "x", ";", "tb", "->", "widget", ".", "y", "=", "y", ";", "tb", "->", "widget", ".", "h", "=", "MAX", "(", "1", ",", "h", ")", ";", "tb", "->", "widget", ".", "w", "=", "MAX", "(", "1", ",", "w", ")", ";", "}", "pango_layout_set_width", "(", "tb", "->", "layout", ",", "PANGO_SCALE", "*", "(", "tb", "->", "widget", ".", "w", "-", "widget_padding_get_padding_width", "(", "WIDGET", "(", "tb", ")", ")", "-", "offset", ")", ")", ";", "widget_queue_redraw", "(", "WIDGET", "(", "tb", ")", ")", ";", "}" ]

[ "within", "the", "parent", "handled", "auto", "width", "/", "height", "modes" ]

[ "// set ellipsize", "// Width determines height!", "// We always want to update this" ]

[ { "param": "tb", "type": "textbox" }, { "param": "x", "type": "int" }, { "param": "y", "type": "int" }, { "param": "w", "type": "int" }, { "param": "h", "type": "int" } ]

[ "MIT" ]

[ "will", "also", "unmap", "the", "window", "if", "still", "displayed" ]

[ "static", "void", "textbox_free", "(", "widget", "*", "wid", ")", "{", "if", "(", "wid", "==", "NULL", ")", "{", "return", ";", "}", "textbox", "*", "tb", "=", "(", "textbox", "*", ")", "wid", ";", "if", "(", "tb", "->", "blink_timeout", ">", "0", ")", "{", "g_source_remove", "(", "tb", "->", "blink_timeout", ")", ";", "tb", "->", "blink_timeout", "=", "0", ";", "}", "g_free", "(", "tb", "->", "text", ")", ";", "if", "(", "tb", "->", "icon", ")", "{", "cairo_surface_destroy", "(", "tb", "->", "icon", ")", ";", "tb", "->", "icon", "=", "NULL", ";", "}", "if", "(", "tb", "->", "layout", "!=", "NULL", ")", "{", "g_object_unref", "(", "tb", "->", "layout", ")", ";", "}", "g_slice_free", "(", "textbox", ",", "tb", ")", ";", "}" ]

[ "will", "also", "unmap", "the", "window", "if", "still", "displayed" ]

[]

[ { "param": "wid", "type": "widget" } ]

[ "MIT" ]

[ "@param", "tb", "Handle", "to", "the", "textbox", "Move", "cursor", "one", "position", "forward", ".", "@returns", "if", "cursor", "was", "moved", "." ]

[ "static", "int", "textbox_cursor_inc", "(", "textbox", "*", "tb", ")", "{", "int", "old", "=", "tb", "->", "cursor", ";", "textbox_cursor", "(", "tb", ",", "tb", "->", "cursor", "+", "1", ")", ";", "return", "old", "!=", "tb", "->", "cursor", ";", "}" ]

[ "@param", "tb", "Handle", "to", "the", "textbox", "Move", "cursor", "one", "position", "forward", "." ]

[]

[ { "param": "tb", "type": "textbox" } ]

[ "MIT" ]

[ "@param", "tb", "Handle", "to", "the", "textbox", "Move", "cursor", "one", "position", "backward", ".", "@returns", "if", "cursor", "was", "moved", "." ]

[ "static", "int", "textbox_cursor_dec", "(", "textbox", "*", "tb", ")", "{", "int", "old", "=", "tb", "->", "cursor", ";", "textbox_cursor", "(", "tb", ",", "tb", "->", "cursor", "-", "1", ")", ";", "return", "old", "!=", "tb", "->", "cursor", ";", "}" ]

[ "@param", "tb", "Handle", "to", "the", "textbox", "Move", "cursor", "one", "position", "backward", "." ]

[]

[ { "param": "tb", "type": "textbox" } ]

[ "MIT" ]

[ "@param", "tb", "Handle", "to", "the", "textbox", "Delete", "character", "after", "cursor", "." ]

[ "static", "void", "textbox_cursor_del", "(", "textbox", "*", "tb", ")", "{", "if", "(", "tb", "==", "NULL", "||", "tb", "->", "text", "==", "NULL", ")", "{", "return", ";", "}", "textbox_delete", "(", "tb", ",", "tb", "->", "cursor", ",", "1", ")", ";", "}" ]

[ "@param", "tb", "Handle", "to", "the", "textbox", "Delete", "character", "after", "cursor", "." ]

[]

[ { "param": "tb", "type": "textbox" } ]

[ "MIT" ]

[ "@param", "tb", "Handle", "to", "the", "textbox", "Delete", "character", "before", "cursor", "." ]

[ "static", "void", "textbox_cursor_bkspc", "(", "textbox", "*", "tb", ")", "{", "if", "(", "tb", "&&", "tb", "->", "cursor", ">", "0", ")", "{", "textbox_cursor_dec", "(", "tb", ")", ";", "textbox_cursor_del", "(", "tb", ")", ";", "}", "}" ]

[ "@param", "tb", "Handle", "to", "the", "textbox", "Delete", "character", "before", "cursor", "." ]

[]

[ { "param": "tb", "type": "textbox" } ]

[ "MIT" ]

[ "@param", "host", "The", "host", "to", "connect", "too", "SSH", "into", "the", "selected", "host", ".", "@returns", "FALSE", "On", "failure", "TRUE", "on", "success" ]

[ "static", "int", "execshssh", "(", "const", "char", "*", "host", ")", "{", "char", "*", "*", "args", "=", "NULL", ";", "int", "argsv", "=", "0", ";", "helper_parse_setup", "(", "config", ".", "ssh_command", ",", "&", "args", ",", "&", "argsv", ",", "\"", "\"", ",", "host", ",", "(", "char", "*", ")", "0", ")", ";", "gsize", "l", "=", "strlen", "(", "\"", "\"", ")", "+", "strlen", "(", "host", ")", "+", "1", ";", "gchar", "*", "desc", "=", "g_newa", "(", "gchar", ",", "l", ")", ";", "g_snprintf", "(", "desc", ",", "l", ",", "\"", "\"", ",", "host", ")", ";", "RofiHelperExecuteContext", "context", "=", "{", ".", "name", "=", "\"", "\"", ",", ".", "description", "=", "desc", ",", ".", "command", "=", "\"", "\"", ",", "}", ";", "return", "helper_execute", "(", "NULL", ",", "args", ",", "\"", "\"", ",", "host", ",", "&", "context", ")", ";", "}" ]

[ "@param", "host", "The", "host", "to", "connect", "too", "SSH", "into", "the", "selected", "host", "." ]

[]

[ { "param": "host", "type": "char" } ]

[ "MIT" ]

[ "@param", "sw", "Object", "handle", "to", "the", "SSH", "Mode", "object", "@param", "mretv", "The", "menu", "return", "value", ".", "@param", "input", "Pointer", "to", "the", "user", "input", "string", ".", "@param", "selected_line", "the", "line", "selected", "by", "the", "user", ".", "Acts", "on", "the", "user", "interaction", ".", "@returns", "the", "next", "#ModeMode", "." ]

[ "static", "ModeMode", "ssh_mode_result", "(", "Mode", "*", "sw", ",", "int", "mretv", ",", "char", "*", "*", "input", ",", "unsigned", "int", "selected_line", ")", "{", "ModeMode", "retv", "=", "MODE_EXIT", ";", "SSHModePrivateData", "*", "rmpd", "=", "(", "SSHModePrivateData", "*", ")", "mode_get_private_data", "(", "sw", ")", ";", "if", "(", "mretv", "&", "MENU_NEXT", ")", "{", "retv", "=", "NEXT_DIALOG", ";", "}", "else", "if", "(", "mretv", "&", "MENU_PREVIOUS", ")", "{", "retv", "=", "PREVIOUS_DIALOG", ";", "}", "else", "if", "(", "mretv", "&", "MENU_QUICK_SWITCH", ")", "{", "retv", "=", "(", "mretv", "&", "MENU_LOWER_MASK", ")", ";", "}", "else", "if", "(", "(", "mretv", "&", "MENU_OK", ")", "&&", "rmpd", "->", "hosts_list", "[", "selected_line", "]", "!=", "NULL", ")", "{", "exec_ssh", "(", "rmpd", "->", "hosts_list", "[", "selected_line", "]", ")", ";", "}", "else", "if", "(", "(", "mretv", "&", "MENU_CUSTOM_INPUT", ")", "&&", "*", "input", "!=", "NULL", "&&", "*", "input", "[", "0", "]", "!=", "'", "\\0", "'", ")", "{", "exec_ssh", "(", "*", "input", ")", ";", "}", "else", "if", "(", "(", "mretv", "&", "MENU_ENTRY_DELETE", ")", "&&", "rmpd", "->", "hosts_list", "[", "selected_line", "]", ")", "{", "delete_ssh", "(", "rmpd", "->", "hosts_list", "[", "selected_line", "]", ")", ";", "retv", "=", "RELOAD_DIALOG", ";", "ssh_mode_destroy", "(", "sw", ")", ";", "ssh_mode_init", "(", "sw", ")", ";", "}", "return", "retv", ";", "}" ]

[ "@param", "sw", "Object", "handle", "to", "the", "SSH", "Mode", "object", "@param", "mretv", "The", "menu", "return", "value", "." ]

[ "// Stay" ]

[ { "param": "sw", "type": "Mode" }, { "param": "mretv", "type": "int" }, { "param": "input", "type": "char" }, { "param": "selected_line", "type": "unsigned int" } ]

[ "MIT" ]

[ "@param", "sw", "Object", "handle", "to", "the", "SSH", "Mode", "object", "@param", "tokens", "The", "set", "of", "tokens", "to", "match", "against", "@param", "index", "The", "index", "of", "the", "entry", "to", "match", "Match", "entry", "against", "the", "set", "of", "tokens", ".", "@returns", "TRUE", "if", "matches" ]

[ "static", "int", "ssh_token_match", "(", "const", "Mode", "*", "sw", ",", "rofi_int_matcher", "*", "*", "tokens", ",", "unsigned", "int", "index", ")", "{", "SSHModePrivateData", "*", "rmpd", "=", "(", "SSHModePrivateData", "*", ")", "mode_get_private_data", "(", "sw", ")", ";", "return", "helper_token_match", "(", "tokens", ",", "rmpd", "->", "hosts_list", "[", "index", "]", ")", ";", "}" ]

[ "@param", "sw", "Object", "handle", "to", "the", "SSH", "Mode", "object", "@param", "tokens", "The", "set", "of", "tokens", "to", "match", "against", "@param", "index", "The", "index", "of", "the", "entry", "to", "match" ]

[]

[ { "param": "sw", "type": "Mode" }, { "param": "tokens", "type": "rofi_int_matcher" }, { "param": "index", "type": "unsigned int" } ]

[ "Artistic-2.0" ]

[ "Enlarge", "the", "memory", "allocation", "on", "a", "StrAccum", "object", "so", "that", "it", "is", "able", "to", "accept", "at", "least", "N", "more", "bytes", "of", "text", ".", "Return", "the", "number", "of", "bytes", "of", "text", "that", "StrAccum", "is", "able", "to", "accept", "after", "the", "attempted", "enlargement", ".", "The", "value", "returned", "might", "be", "zero", "." ]

[ "static", "int", "sqlite3StrAccumEnlarge", "(", "StrAccum", "*", "p", ",", "int", "N", ")", "{", "char", "*", "zNew", ";", "assert", "(", "p", "->", "nChar", "+", "(", "i64", ")", "N", ">=", "p", "->", "nAlloc", ")", ";", "if", "(", "p", "->", "accError", ")", "{", "testcase", "(", "p", "->", "accError", "==", "STRACCUM_TOOBIG", ")", ";", "testcase", "(", "p", "->", "accError", "==", "STRACCUM_NOMEM", ")", ";", "return", "0", ";", "}", "if", "(", "p", "->", "mxAlloc", "==", "0", ")", "{", "N", "=", "p", "->", "nAlloc", "-", "p", "->", "nChar", "-", "1", ";", "setStrAccumError", "(", "p", ",", "STRACCUM_TOOBIG", ")", ";", "return", "N", ";", "}", "else", "{", "char", "*", "zOld", "=", "(", "p", "->", "zText", "==", "p", "->", "zBase", "?", "0", ":", "p", "->", "zText", ")", ";", "i64", "szNew", "=", "p", "->", "nChar", ";", "szNew", "+=", "N", "+", "1", ";", "if", "(", "szNew", "+", "p", "->", "nChar", "<=", "p", "->", "mxAlloc", ")", "{", "szNew", "+=", "p", "->", "nChar", ";", "}", "if", "(", "szNew", ">", "p", "->", "mxAlloc", ")", "{", "sqlite3StrAccumReset", "(", "p", ")", ";", "setStrAccumError", "(", "p", ",", "STRACCUM_TOOBIG", ")", ";", "return", "0", ";", "}", "else", "{", "p", "->", "nAlloc", "=", "(", "int", ")", "szNew", ";", "}", "if", "(", "p", "->", "db", ")", "{", "zNew", "=", "sqlite3DbRealloc", "(", "p", "->", "db", ",", "zOld", ",", "p", "->", "nAlloc", ")", ";", "}", "else", "{", "zNew", "=", "sqlite3_realloc64", "(", "zOld", ",", "p", "->", "nAlloc", ")", ";", "}", "if", "(", "zNew", ")", "{", "assert", "(", "p", "->", "zText", "!=", "0", "||", "p", "->", "nChar", "==", "0", ")", ";", "if", "(", "zOld", "==", "0", "&&", "p", "->", "nChar", ">", "0", ")", "memcpy", "(", "zNew", ",", "p", "->", "zText", ",", "p", "->", "nChar", ")", ";", "p", "->", "zText", "=", "zNew", ";", "p", "->", "nAlloc", "=", "sqlite3DbMallocSize", "(", "p", "->", "db", ",", "zNew", ")", ";", "}", "else", "{", "sqlite3StrAccumReset", "(", "p", ")", ";", "setStrAccumError", "(", "p", ",", "STRACCUM_NOMEM", ")", ";", "return", "0", ";", "}", "}", "return", "N", ";", "}" ]

[ "Enlarge", "the", "memory", "allocation", "on", "a", "StrAccum", "object", "so", "that", "it", "is", "able", "to", "accept", "at", "least", "N", "more", "bytes", "of", "text", "." ]

[ "/* Only called if really needed */", "/* Force exponential buffer size growth as long as it does not overflow,\n ** to avoid having to call this routine too often */" ]

[ { "param": "p", "type": "StrAccum" }, { "param": "N", "type": "int" } ]

[ "Artistic-2.0" ]

[ "Append", "N", "copies", "of", "character", "c", "to", "the", "given", "string", "buffer", "." ]

[ "void", "sqlite3AppendChar", "(", "StrAccum", "*", "p", ",", "int", "N", ",", "char", "c", ")", "{", "testcase", "(", "p", "->", "nChar", "+", "(", "i64", ")", "N", ">", "0x7fffffff", ")", ";", "if", "(", "p", "->", "nChar", "+", "(", "i64", ")", "N", ">=", "p", "->", "nAlloc", "&&", "(", "N", "=", "sqlite3StrAccumEnlarge", "(", "p", ",", "N", ")", ")", "<=", "0", ")", "{", "return", ";", "}", "while", "(", "(", "N", "--", ")", ">", "0", ")", "p", "->", "zText", "[", "p", "->", "nChar", "++", "]", "=", "c", ";", "}" ]

[ "Append", "N", "copies", "of", "character", "c", "to", "the", "given", "string", "buffer", "." ]

[]

[ { "param": "p", "type": "StrAccum" }, { "param": "N", "type": "int" }, { "param": "c", "type": "char" } ]

[ "Artistic-2.0" ]

[ "Finish", "off", "a", "string", "by", "making", "sure", "it", "is", "zero", "-", "terminated", ".", "Return", "a", "pointer", "to", "the", "resulting", "string", ".", "Return", "a", "NULL", "pointer", "if", "any", "kind", "of", "error", "was", "encountered", "." ]

[ "char", "*", "sqlite3StrAccumFinish", "(", "StrAccum", "*", "p", ")", "{", "if", "(", "p", "->", "zText", ")", "{", "p", "->", "zText", "[", "p", "->", "nChar", "]", "=", "0", ";", "if", "(", "p", "->", "mxAlloc", ">", "0", "&&", "p", "->", "zText", "==", "p", "->", "zBase", ")", "{", "p", "->", "zText", "=", "sqlite3DbMallocRaw", "(", "p", "->", "db", ",", "p", "->", "nChar", "+", "1", ")", ";", "if", "(", "p", "->", "zText", ")", "{", "memcpy", "(", "p", "->", "zText", ",", "p", "->", "zBase", ",", "p", "->", "nChar", "+", "1", ")", ";", "}", "else", "{", "setStrAccumError", "(", "p", ",", "STRACCUM_NOMEM", ")", ";", "}", "}", "}", "return", "p", "->", "zText", ";", "}" ]

[ "Finish", "off", "a", "string", "by", "making", "sure", "it", "is", "zero", "-", "terminated", "." ]

[]

[ { "param": "p", "type": "StrAccum" } ]

[ "Artistic-2.0" ]

[ "Reset", "an", "StrAccum", "string", ".", "Reclaim", "all", "malloced", "memory", "." ]

[ "void", "sqlite3StrAccumReset", "(", "StrAccum", "*", "p", ")", "{", "if", "(", "p", "->", "zText", "!=", "p", "->", "zBase", ")", "{", "sqlite3DbFree", "(", "p", "->", "db", ",", "p", "->", "zText", ")", ";", "}", "p", "->", "zText", "=", "0", ";", "}" ]

[ "Reset", "an", "StrAccum", "string", "." ]

[]

[ { "param": "p", "type": "StrAccum" } ]

[ "Artistic-2.0" ]

[ "Initialize", "a", "string", "accumulator", ".", "p", ":", "The", "accumulator", "to", "be", "initialized", ".", "db", ":", "Pointer", "to", "a", "database", "connection", ".", "May", "be", "NULL", ".", "Lookaside", "memory", "is", "used", "if", "not", "NULL", ".", "db", "-", ">", "mallocFailed", "is", "set", "appropriately", "when", "not", "NULL", ".", "zBase", ":", "An", "initial", "buffer", ".", "May", "be", "NULL", "in", "which", "case", "the", "initial", "buffer", "is", "malloced", ".", "n", ":", "Size", "of", "zBase", "in", "bytes", ".", "If", "total", "space", "requirements", "never", "exceed", "n", "then", "no", "memory", "allocations", "ever", "occur", ".", "mx", ":", "Maximum", "number", "of", "bytes", "to", "accumulate", ".", "If", "mx", "==", "0", "then", "no", "memory", "allocations", "will", "ever", "occur", "." ]

[ "void", "sqlite3StrAccumInit", "(", "StrAccum", "*", "p", ",", "sqlite3", "*", "db", ",", "char", "*", "zBase", ",", "int", "n", ",", "int", "mx", ")", "{", "p", "->", "zText", "=", "p", "->", "zBase", "=", "zBase", ";", "p", "->", "db", "=", "db", ";", "p", "->", "nChar", "=", "0", ";", "p", "->", "nAlloc", "=", "n", ";", "p", "->", "mxAlloc", "=", "mx", ";", "p", "->", "accError", "=", "0", ";", "}" ]

[ "Initialize", "a", "string", "accumulator", "." ]

[]

[ { "param": "p", "type": "StrAccum" }, { "param": "db", "type": "sqlite3" }, { "param": "zBase", "type": "char" }, { "param": "n", "type": "int" }, { "param": "mx", "type": "int" } ]

[ "Artistic-2.0" ]

[ "Print", "into", "memory", "obtained", "from", "sqliteMalloc", "()", ".", "Use", "the", "internal", "%", "-", "conversion", "extensions", "." ]

[ "char", "*", "sqlite3VMPrintf", "(", "sqlite3", "*", "db", ",", "const", "char", "*", "zFormat", ",", "va_list", "ap", ")", "{", "char", "*", "z", ";", "char", "zBase", "[", "SQLITE_PRINT_BUF_SIZE", "]", ";", "StrAccum", "acc", ";", "assert", "(", "db", "!=", "0", ")", ";", "sqlite3StrAccumInit", "(", "&", "acc", ",", "db", ",", "zBase", ",", "sizeof", "(", "zBase", ")", ",", "db", "->", "aLimit", "[", "SQLITE_LIMIT_LENGTH", "]", ")", ";", "sqlite3VXPrintf", "(", "&", "acc", ",", "SQLITE_PRINTF_INTERNAL", ",", "zFormat", ",", "ap", ")", ";", "z", "=", "sqlite3StrAccumFinish", "(", "&", "acc", ")", ";", "if", "(", "acc", ".", "accError", "==", "STRACCUM_NOMEM", ")", "{", "db", "->", "mallocFailed", "=", "1", ";", "}", "return", "z", ";", "}" ]

[ "Print", "into", "memory", "obtained", "from", "sqliteMalloc", "()", "." ]

[]

[ { "param": "db", "type": "sqlite3" }, { "param": "zFormat", "type": "char" }, { "param": "ap", "type": "va_list" } ]

[ "Artistic-2.0" ]

[ "Like", "sqlite3MPrintf", "()", "but", "call", "sqlite3DbFree", "()", "on", "zStr", "after", "formatting", "the", "string", "and", "before", "returning", ".", "This", "routine", "is", "intended", "to", "be", "used", "to", "modify", "an", "existing", "string", ".", "For", "example", "." ]

[ "char", "*", "sqlite3MAppendf", "(", "sqlite3", "*", "db", ",", "char", "*", "zStr", ",", "const", "char", "*", "zFormat", ",", "...", ")", "{", "va_list", "ap", ";", "char", "*", "z", ";", "va_start", "(", "ap", ",", "zFormat", ")", ";", "z", "=", "sqlite3VMPrintf", "(", "db", ",", "zFormat", ",", "ap", ")", ";", "va_end", "(", "ap", ")", ";", "sqlite3DbFree", "(", "db", ",", "zStr", ")", ";", "return", "z", ";", "}" ]

[ "Like", "sqlite3MPrintf", "()", "but", "call", "sqlite3DbFree", "()", "on", "zStr", "after", "formatting", "the", "string", "and", "before", "returning", "." ]

[]

[ { "param": "db", "type": "sqlite3" }, { "param": "zStr", "type": "char" }, { "param": "zFormat", "type": "char" } ]

[ "Artistic-2.0" ]

[ "Print", "into", "memory", "obtained", "from", "sqlite3_malloc", "()", ".", "Omit", "the", "internal", "%", "-", "conversion", "extensions", "." ]

[ "char", "*", "sqlite3_vmprintf", "(", "const", "char", "*", "zFormat", ",", "va_list", "ap", ")", "{", "char", "*", "z", ";", "char", "zBase", "[", "SQLITE_PRINT_BUF_SIZE", "]", ";", "StrAccum", "acc", ";", "#ifdef", "SQLITE_ENABLE_API_ARMOR", "if", "(", "zFormat", "==", "0", ")", "{", "(", "void", ")", "SQLITE_MISUSE_BKPT", ";", "return", "0", ";", "}", "#endif", "#ifndef", "SQLITE_OMIT_AUTOINIT", "if", "(", "sqlite3_initialize", "(", ")", ")", "return", "0", ";", "#endif", "sqlite3StrAccumInit", "(", "&", "acc", ",", "0", ",", "zBase", ",", "sizeof", "(", "zBase", ")", ",", "SQLITE_MAX_LENGTH", ")", ";", "sqlite3VXPrintf", "(", "&", "acc", ",", "0", ",", "zFormat", ",", "ap", ")", ";", "z", "=", "sqlite3StrAccumFinish", "(", "&", "acc", ")", ";", "return", "z", ";", "}" ]

[ "Print", "into", "memory", "obtained", "from", "sqlite3_malloc", "()", "." ]

[]

[ { "param": "zFormat", "type": "char" }, { "param": "ap", "type": "va_list" } ]

[ "Artistic-2.0" ]

[ "sqlite3_snprintf", "()", "works", "like", "snprintf", "()", "except", "that", "it", "ignores", "the", "current", "locale", "settings", ".", "This", "is", "important", "for", "SQLite", "because", "we", "are", "not", "able", "to", "use", "a", "\"", "\"", "as", "the", "decimal", "point", "in", "place", "of", "\"", ".", "\"", "as", "specified", "by", "some", "locales", ".", "The", "first", "two", "arguments", "of", "sqlite3_snprintf", "()", "are", "backwards", "from", "the", "snprintf", "()", "standard", ".", "Unfortunately", "it", "is", "too", "late", "to", "change", "this", "without", "breaking", "compatibility", "so", "we", "just", "have", "to", "live", "with", "the", "mistake", ".", "sqlite3_vsnprintf", "()", "is", "the", "varargs", "version", "." ]

[ "char", "*", "sqlite3_vsnprintf", "(", "int", "n", ",", "char", "*", "zBuf", ",", "const", "char", "*", "zFormat", ",", "va_list", "ap", ")", "{", "StrAccum", "acc", ";", "if", "(", "n", "<=", "0", ")", "return", "zBuf", ";", "#ifdef", "SQLITE_ENABLE_API_ARMOR", "if", "(", "zBuf", "==", "0", "||", "zFormat", "==", "0", ")", "{", "(", "void", ")", "SQLITE_MISUSE_BKPT", ";", "if", "(", "zBuf", ")", "zBuf", "[", "0", "]", "=", "0", ";", "return", "zBuf", ";", "}", "#endif", "sqlite3StrAccumInit", "(", "&", "acc", ",", "0", ",", "zBuf", ",", "n", ",", "0", ")", ";", "sqlite3VXPrintf", "(", "&", "acc", ",", "0", ",", "zFormat", ",", "ap", ")", ";", "return", "sqlite3StrAccumFinish", "(", "&", "acc", ")", ";", "}" ]

[ "sqlite3_snprintf", "()", "works", "like", "snprintf", "()", "except", "that", "it", "ignores", "the", "current", "locale", "settings", "." ]

[]

[ { "param": "n", "type": "int" }, { "param": "zBuf", "type": "char" }, { "param": "zFormat", "type": "char" }, { "param": "ap", "type": "va_list" } ]

[ "Artistic-2.0" ]

[ "This", "is", "the", "routine", "that", "actually", "formats", "the", "sqlite3_log", "()", "message", ".", "We", "house", "it", "in", "a", "separate", "routine", "from", "sqlite3_log", "()", "to", "avoid", "using", "stack", "space", "on", "small", "-", "stack", "systems", "when", "logging", "is", "disabled", ".", "sqlite3_log", "()", "must", "render", "into", "a", "static", "buffer", ".", "It", "cannot", "dynamically", "allocate", "memory", "because", "it", "might", "be", "called", "while", "the", "memory", "allocator", "mutex", "is", "held", "." ]

[ "static", "void", "renderLogMsg", "(", "int", "iErrCode", ",", "const", "char", "*", "zFormat", ",", "va_list", "ap", ")", "{", "StrAccum", "acc", ";", "char", "zMsg", "[", "SQLITE_PRINT_BUF_SIZE", "*", "3", "]", ";", "sqlite3StrAccumInit", "(", "&", "acc", ",", "0", ",", "zMsg", ",", "sizeof", "(", "zMsg", ")", ",", "0", ")", ";", "sqlite3VXPrintf", "(", "&", "acc", ",", "0", ",", "zFormat", ",", "ap", ")", ";", "sqlite3GlobalConfig", ".", "xLog", "(", "sqlite3GlobalConfig", ".", "pLogArg", ",", "iErrCode", ",", "sqlite3StrAccumFinish", "(", "&", "acc", ")", ")", ";", "}" ]

[ "This", "is", "the", "routine", "that", "actually", "formats", "the", "sqlite3_log", "()", "message", "." ]

[ "/* String accumulator */", "/* Complete log message */" ]

[ { "param": "iErrCode", "type": "int" }, { "param": "zFormat", "type": "char" }, { "param": "ap", "type": "va_list" } ]

[ "Artistic-2.0" ]

[ "A", "version", "of", "printf", "()", "that", "understands", "%lld", ".", "Used", "for", "debugging", ".", "The", "printf", "()", "built", "into", "some", "versions", "of", "windows", "does", "not", "understand", "%lld", "and", "segfaults", "if", "you", "give", "it", "a", "long", "long", "int", "." ]

[ "void", "sqlite3DebugPrintf", "(", "const", "char", "*", "zFormat", ",", "...", ")", "{", "va_list", "ap", ";", "StrAccum", "acc", ";", "char", "zBuf", "[", "500", "]", ";", "sqlite3StrAccumInit", "(", "&", "acc", ",", "0", ",", "zBuf", ",", "sizeof", "(", "zBuf", ")", ",", "0", ")", ";", "va_start", "(", "ap", ",", "zFormat", ")", ";", "sqlite3VXPrintf", "(", "&", "acc", ",", "0", ",", "zFormat", ",", "ap", ")", ";", "va_end", "(", "ap", ")", ";", "sqlite3StrAccumFinish", "(", "&", "acc", ")", ";", "fprintf", "(", "stdout", ",", "\"", "\"", ",", "zBuf", ")", ";", "fflush", "(", "stdout", ")", ";", "}" ]

[ "A", "version", "of", "printf", "()", "that", "understands", "%lld", "." ]

[]

[ { "param": "zFormat", "type": "char" } ]

[ "Artistic-2.0" ]

[ "Add", "a", "new", "subitem", "to", "the", "tree", ".", "The", "moreToFollow", "flag", "indicates", "that", "this", "is", "not", "the", "last", "item", "in", "the", "tree", "." ]

[ "TreeView", "*", "sqlite3TreeViewPush", "(", "TreeView", "*", "p", ",", "u8", "moreToFollow", ")", "{", "if", "(", "p", "==", "0", ")", "{", "p", "=", "sqlite3_malloc64", "(", "sizeof", "(", "*", "p", ")", ")", ";", "if", "(", "p", "==", "0", ")", "return", "0", ";", "memset", "(", "p", ",", "0", ",", "sizeof", "(", "*", "p", ")", ")", ";", "}", "else", "{", "p", "->", "iLevel", "++", ";", "}", "assert", "(", "moreToFollow", "==", "0", "||", "moreToFollow", "==", "1", ")", ";", "if", "(", "p", "->", "iLevel", "<", "sizeof", "(", "p", "->", "bLine", ")", ")", "p", "->", "bLine", "[", "p", "->", "iLevel", "]", "=", "moreToFollow", ";", "return", "p", ";", "}" ]

[ "Add", "a", "new", "subitem", "to", "the", "tree", "." ]

[]

[ { "param": "p", "type": "TreeView" }, { "param": "moreToFollow", "type": "u8" } ]

[ "Artistic-2.0" ]

[ "Finished", "with", "one", "layer", "of", "the", "tree" ]

[ "void", "sqlite3TreeViewPop", "(", "TreeView", "*", "p", ")", "{", "if", "(", "p", "==", "0", ")", "return", ";", "p", "->", "iLevel", "--", ";", "if", "(", "p", "->", "iLevel", "<", "0", ")", "sqlite3_free", "(", "p", ")", ";", "}" ]

[ "Finished", "with", "one", "layer", "of", "the", "tree" ]

[]

[ { "param": "p", "type": "TreeView" } ]

[ "Artistic-2.0" ]

[ "Generate", "a", "single", "line", "of", "output", "for", "the", "tree", "with", "a", "prefix", "that", "contains", "all", "the", "appropriate", "tree", "lines" ]

[ "void", "sqlite3TreeViewLine", "(", "TreeView", "*", "p", ",", "const", "char", "*", "zFormat", ",", "...", ")", "{", "va_list", "ap", ";", "int", "i", ";", "StrAccum", "acc", ";", "char", "zBuf", "[", "500", "]", ";", "sqlite3StrAccumInit", "(", "&", "acc", ",", "0", ",", "zBuf", ",", "sizeof", "(", "zBuf", ")", ",", "0", ")", ";", "if", "(", "p", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "p", "->", "iLevel", "&&", "i", "<", "sizeof", "(", "p", "->", "bLine", ")", "-", "1", ";", "i", "++", ")", "{", "sqlite3StrAccumAppend", "(", "&", "acc", ",", "p", "->", "bLine", "[", "i", "]", "?", "\"", "\"", ":", "\"", "\"", ",", "4", ")", ";", "}", "sqlite3StrAccumAppend", "(", "&", "acc", ",", "p", "->", "bLine", "[", "i", "]", "?", "\"", "\"", ":", "\"", "\"", ",", "4", ")", ";", "}", "va_start", "(", "ap", ",", "zFormat", ")", ";", "sqlite3VXPrintf", "(", "&", "acc", ",", "0", ",", "zFormat", ",", "ap", ")", ";", "va_end", "(", "ap", ")", ";", "if", "(", "zBuf", "[", "acc", ".", "nChar", "-", "1", "]", "!=", "'", "\\n", "'", ")", "sqlite3StrAccumAppend", "(", "&", "acc", ",", "\"", "\\n", "\"", ",", "1", ")", ";", "sqlite3StrAccumFinish", "(", "&", "acc", ")", ";", "fprintf", "(", "stdout", ",", "\"", "\"", ",", "zBuf", ")", ";", "fflush", "(", "stdout", ")", ";", "}" ]

[ "Generate", "a", "single", "line", "of", "output", "for", "the", "tree", "with", "a", "prefix", "that", "contains", "all", "the", "appropriate", "tree", "lines" ]

[]

[ { "param": "p", "type": "TreeView" }, { "param": "zFormat", "type": "char" } ]

[ "Artistic-2.0" ]

[ "variable", "-", "argument", "wrapper", "around", "sqlite3VXPrintf", "()", "." ]

[ "void", "sqlite3XPrintf", "(", "StrAccum", "*", "p", ",", "u32", "bFlags", ",", "const", "char", "*", "zFormat", ",", "...", ")", "{", "va_list", "ap", ";", "va_start", "(", "ap", ",", "zFormat", ")", ";", "sqlite3VXPrintf", "(", "p", ",", "bFlags", ",", "zFormat", ",", "ap", ")", ";", "va_end", "(", "ap", ")", ";", "}" ]

[ "variable", "-", "argument", "wrapper", "around", "sqlite3VXPrintf", "()", "." ]

[]

[ { "param": "p", "type": "StrAccum" }, { "param": "bFlags", "type": "u32" }, { "param": "zFormat", "type": "char" } ]

[ "MIT" ]

[ "union", "by", "rank", "if", "either", "set", "is", "marked", "then", "the", "result", "is", "marked" ]

[ "void", "merge", "(", "size_t", "x", ",", "size_t", "y", ")", "{", "x", "=", "find", "(", "x", ")", ";", "y", "=", "find", "(", "y", ")", ";", "if", "(", "rank", "[", "x", "]", ">", "rank", "[", "y", "]", ")", "parent", "[", "y", "]", "=", "x", ";", "else", "parent", "[", "x", "]", "=", "y", ";", "if", "(", "rank", "[", "x", "]", "==", "rank", "[", "y", "]", ")", "rank", "[", "y", "]", "++", ";", "if", "(", "marked", "[", "x", "]", "||", "marked", "[", "y", "]", ")", "{", "marked", "[", "x", "]", "=", "true", ";", "marked", "[", "y", "]", "=", "true", ";", "}", "}" ]

[ "union", "by", "rank", "if", "either", "set", "is", "marked", "then", "the", "result", "is", "marked" ]

[ "// smaller tree becomes a subtree of the larger tree", "// if either set was marked, both are marked" ]

[ { "param": "x", "type": "size_t" }, { "param": "y", "type": "size_t" } ]

[ "BSD-2-Clause" ]

[ "list_add", "inserts", "a", "new", "node", "with", "the", "given", "value", "val", "in", "the", "list", "(", "if", "the", "value", "was", "absent", ")", "or", "does", "nothing", "(", "if", "the", "value", "is", "already", "present", ")", "." ]

[ "int", "list_add", "(", "llist_t", "*", "list", ",", "val_t", "val", ")", "{", "node_t", "*", "e", "=", "node_new", "(", "val", ",", "NULL", ")", ";", "e", "->", "next", "=", "list", "->", "head", ";", "list", "->", "head", "=", "e", ";", "list", "->", "size", "++", ";", "return", "0", ";", "}" ]

[ "list_add", "inserts", "a", "new", "node", "with", "the", "given", "value", "val", "in", "the", "list", "(", "if", "the", "value", "was", "absent", ")", "or", "does", "nothing", "(", "if", "the", "value", "is", "already", "present", ")", "." ]

[]

[ { "param": "list", "type": "llist_t" }, { "param": "val", "type": "val_t" } ]

[ "BSD-2-Clause" ]

[ "get", "the", "node", "specify", "by", "index", "if", "the", "index", "is", "out", "of", "range", "it", "will", "return", "NULL" ]

[ "node_t", "*", "list_nth", "(", "llist_t", "*", "list", ",", "uint32_t", "idx", ")", "{", "if", "(", "idx", ">", "list", "->", "size", ")", "return", "NULL", ";", "node_t", "*", "head", "=", "list", "->", "head", ";", "while", "(", "idx", "--", ")", "head", "=", "head", "->", "next", ";", "return", "head", ";", "}" ]

[ "get", "the", "node", "specify", "by", "index", "if", "the", "index", "is", "out", "of", "range", "it", "will", "return", "NULL" ]

[]

[ { "param": "list", "type": "llist_t" }, { "param": "idx", "type": "uint32_t" } ]

[ "MIT" ]

[ "@brief", "This", "function", "handles", "I2C1", "event", "global", "interrupt", "/", "I2C1", "wake", "-", "up", "interrupt", "through", "EXTI", "line", "23", "." ]

[ "void", "I2C1_EV_IRQHandler", "(", "void", ")", "{", "HAL_SMBUS_EV_IRQHandler", "(", "&", "hsmbus1", ")", ";", "}" ]

[ "@brief", "This", "function", "handles", "I2C1", "event", "global", "interrupt", "/", "I2C1", "wake", "-", "up", "interrupt", "through", "EXTI", "line", "23", "." ]

[ "/* USER CODE BEGIN I2C1_EV_IRQn 0 */", "/* USER CODE END I2C1_EV_IRQn 0 */", "/* USER CODE BEGIN I2C1_EV_IRQn 1 */", "/* USER CODE END I2C1_EV_IRQn 1 */" ]

[]

[ "MIT" ]

[ "@brief", "This", "function", "handles", "I2C1", "error", "interrupt", "." ]

[ "void", "I2C1_ER_IRQHandler", "(", "void", ")", "{", "HAL_SMBUS_ER_IRQHandler", "(", "&", "hsmbus1", ")", ";", "}" ]

[ "@brief", "This", "function", "handles", "I2C1", "error", "interrupt", "." ]

[ "/* USER CODE BEGIN I2C1_ER_IRQn 0 */", "/* USER CODE END I2C1_ER_IRQn 0 */", "/* USER CODE BEGIN I2C1_ER_IRQn 1 */", "/* USER CODE END I2C1_ER_IRQn 1 */" ]

[]

[ "MIT", "Unlicense" ]

[ "Get", "the", "current", "board", "revision", "." ]

[ "int", "pi_revision", "(", ")", "{", "debug", "(", "\"", "\"", ")", ";", "FILE", "*", "fd", ";", "char", "buf_file", "[", "MAX_BUF", "]", ";", "char", "buf_key", "[", "MAX_BUF", "]", ";", "char", "buf_val", "[", "MAX_BUF", "]", ";", "fd", "=", "fopen", "(", "\"", "\"", ",", "\"", "\"", ")", ";", "if", "(", "fd", "==", "NULL", ")", "{", "debug", "(", "\"", "\"", ")", ";", "return", "-1", ";", "}", "while", "(", "fgets", "(", "buf_file", ",", "sizeof", "(", "buf_file", ")", ",", "fd", ")", "!=", "NULL", ")", "{", "if", "(", "strlen", "(", "buf_file", ")", "==", "1", ")", "continue", ";", "sscanf", "(", "buf_file", ",", "\"", "\\t", "\\t", "\\n", "\"", ",", "buf_key", ",", "buf_val", ")", ";", "if", "(", "strncmp", "(", "\"", "\"", ",", "buf_key", ",", "8", ")", "==", "0", ")", "break", ";", "}", "fclose", "(", "fd", ")", ";", "long", "rev", "=", "strtol", "(", "buf_val", ",", "NULL", ",", "16", ")", ";", "if", "(", "errno", "==", "ERANGE", "||", "rev", "==", "0", ")", "{", "debug", "(", "\"", "\"", ")", ";", "return", "-1", ";", "}", "rev", "%=", "0x10", ";", "int", "res", ";", "switch", "(", "rev", ")", "{", "case", "2", ":", "case", "3", ":", "res", "=", "1", ";", "break", ";", "default", ":", "res", "=", "2", ";", "break", ";", "}", "debug", "(", "\"", "\"", ",", "res", ")", ";", "return", "res", ";", "}" ]

[ "Get", "the", "current", "board", "revision", "." ]

[ "// handle overclocked systems" ]

[]

[ "MIT" ]

[ "write", "a", "string", "to", "an", "existing", "and", "writtable", "file" ]

[ "int", "file_write", "(", "char", "*", "path", ",", "char", "*", "str", ")", "{", "int", "fd", ";", "ssize_t", "bytes_written", ";", "size_t", "str_sz", ";", "fd", "=", "open", "(", "path", ",", "O_WRONLY", ")", ";", "if", "(", "fd", "==", "-1", ")", "{", "perror", "(", "\"", "\"", ")", ";", "return", "-1", ";", "}", "str_sz", "=", "strlen", "(", "str", ")", ";", "bytes_written", "=", "write", "(", "fd", ",", "str", ",", "str_sz", ")", ";", "if", "(", "bytes_written", "!=", "str_sz", ")", "{", "if", "(", "bytes_written", "==", "-1", ")", "{", "perror", "(", "\"", "\"", ")", ";", "}", "close", "(", "fd", ")", ";", "return", "-1", ";", "}", "if", "(", "-1", "==", "close", "(", "fd", ")", ")", "{", "perror", "(", "\"", "\"", ")", ";", "return", "-1", ";", "}", "return", "0", ";", "}" ]

[ "write", "a", "string", "to", "an", "existing", "and", "writtable", "file" ]

[]

[ { "param": "path", "type": "char" }, { "param": "str", "type": "char" } ]

[ "MIT" ]

[ "Get", "beginning", "of", "each", "new", "line", "in", "the", "word", "list" ]

[ "unsigned", "int", "*", "ConvFile", "(", "FILE", "*", "f", ",", "short", "linecount", ")", "{", "fseek", "(", "f", ",", "0", ",", "SEEK_END", ")", ";", "int", "size", "=", "ftell", "(", "f", ")", ";", "fseek", "(", "f", ",", "0", ",", "SEEK_SET", ")", ";", "int", "*", "lines", "=", "malloc", "(", "linecount", "*", "4", ")", ";", "memset", "(", "lines", "-", "1", ",", "0", ",", "linecount", "*", "4", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "linecount", ";", "i", "++", ")", "{", "fgets", "(", "tmp", ",", "max_word_length", ",", "f", ")", ";", "lines", "[", "i", "]", "=", "strlen", "(", "tmp", ")", "+", "lines", "[", "i", "-", "1", "]", "+", "1", ";", "memset", "(", "tmp", ",", "0", ",", "max_word_length", ")", ";", "}", "fseek", "(", "f", ",", "0", ",", "SEEK_SET", ")", ";", "return", "lines", ";", "}" ]

[ "Get", "beginning", "of", "each", "new", "line", "in", "the", "word", "list" ]

[]

[ { "param": "f", "type": "FILE" }, { "param": "linecount", "type": "short" } ]

[ "MIT" ]

[ "read", "Word", "list", "into", "Wordlist", "Object" ]

[ "struct", "WordList", "*", "LoadWordList", "(", "const", "char", "*", "Path", ",", "int", "lines_amount", ")", "{", "struct", "WordList", "*", "List", "=", "malloc", "(", "sizeof", "(", "struct", "WordList", ")", ")", ";", "List", "->", "file", "=", "fopen", "(", "Path", ",", "\"", "\"", ")", ";", "if", "(", "!", "List", "->", "file", ")", "return", "0", ";", "List", "->", "lines_beginging", "=", "ConvFile", "(", "List", "->", "file", ",", "lines_amount", ")", ";", "return", "List", ";", "}" ]

[ "read", "Word", "list", "into", "Wordlist", "Object" ]

[]

[ { "param": "Path", "type": "char" }, { "param": "lines_amount", "type": "int" } ]

[ "Apache-2.0" ]

[ "Stores", "the", "given", "uint32_t", "in", "the", "given", "location", "in", "big", "-", "endian", "sequence" ]

[ "void", "write_uint32", "(", "byte", "*", "ptr", ",", "uint32_t", "input", ")", "{", "int", "i", "=", "4", ";", "while", "(", "i", "--", ")", "*", "ptr", "++", "=", "(", "input", ">>", "(", "8", "*", "i", ")", ")", "&", "0xFF", ";", "}" ]

[ "Stores", "the", "given", "uint32_t", "in", "the", "given", "location", "in", "big", "-", "endian", "sequence" ]

[]

[ { "param": "ptr", "type": "byte" }, { "param": "input", "type": "uint32_t" } ]

[ "Apache-2.0" ]

[ "Stores", "the", "given", "uint64_t", "in", "the", "given", "location", "in", "big", "-", "endian", "sequence" ]

[ "void", "write_uint64", "(", "byte", "*", "ptr", ",", "uint64_t", "input", ")", "{", "int", "i", "=", "8", ";", "while", "(", "i", "--", ")", "*", "ptr", "++", "=", "(", "input", ">>", "(", "8", "*", "i", ")", ")", "&", "0xFF", ";", "}" ]

[ "Stores", "the", "given", "uint64_t", "in", "the", "given", "location", "in", "big", "-", "endian", "sequence" ]

[]

[ { "param": "ptr", "type": "byte" }, { "param": "input", "type": "uint64_t" } ]

[ "Apache-2.0" ]

[ "Stores", "the", "given", "uint16_t", "in", "the", "given", "location", "in", "variable", "integer", "format" ]

[ "int", "write_vint16", "(", "byte", "*", "ptr", ",", "uint16_t", "vint", ")", "{", "int", "len", "=", "get_vlen_of_uint16", "(", "vint", ")", ";", "for", "(", "int", "i", "=", "len", "-", "1", ";", "i", ">", "0", ";", "i", "--", ")", "*", "ptr", "++", "=", "0x80", "+", "(", "(", "vint", ">>", "(", "7", "*", "i", ")", ")", "&", "0x7F", ")", ";", "*", "ptr", "=", "vint", "&", "0x7F", ";", "return", "len", ";", "}" ]

[ "Stores", "the", "given", "uint16_t", "in", "the", "given", "location", "in", "variable", "integer", "format" ]

[]

[ { "param": "ptr", "type": "byte" }, { "param": "vint", "type": "uint16_t" } ]

[ "Apache-2.0" ]

[ "Stores", "the", "given", "uint32_t", "in", "the", "given", "location", "in", "variable", "integer", "format" ]

[ "int", "write_vint32", "(", "byte", "*", "ptr", ",", "uint32_t", "vint", ")", "{", "int", "len", "=", "get_vlen_of_uint32", "(", "vint", ")", ";", "for", "(", "int", "i", "=", "len", "-", "1", ";", "i", ">", "0", ";", "i", "--", ")", "*", "ptr", "++", "=", "0x80", "+", "(", "(", "vint", ">>", "(", "7", "*", "i", ")", ")", "&", "0x7F", ")", ";", "*", "ptr", "=", "vint", "&", "0x7F", ";", "return", "len", ";", "}" ]

[ "Stores", "the", "given", "uint32_t", "in", "the", "given", "location", "in", "variable", "integer", "format" ]

[]

[ { "param": "ptr", "type": "byte" }, { "param": "vint", "type": "uint32_t" } ]

[ "Apache-2.0" ]

[ "Reads", "and", "returns", "big", "-", "endian", "uint32_t", "at", "a", "given", "memory", "location" ]

[ "uint32_t", "read_uint32", "(", "byte", "*", "ptr", ")", "{", "uint32_t", "ret", ";", "ret", "=", "(", "(", "uint32_t", ")", "*", "ptr", "++", ")", "<<", "24", ";", "ret", "+=", "(", "(", "uint32_t", ")", "*", "ptr", "++", ")", "<<", "16", ";", "ret", "+=", "(", "(", "uint32_t", ")", "*", "ptr", "++", ")", "<<", "8", ";", "ret", "+=", "*", "ptr", ";", "return", "ret", ";", "}" ]

[ "Reads", "and", "returns", "big", "-", "endian", "uint32_t", "at", "a", "given", "memory", "location" ]

[]

[ { "param": "ptr", "type": "byte" } ]

[ "Apache-2.0" ]

[ "Reads", "and", "returns", "big", "-", "endian", "uint32_t", "at", "a", "given", "memory", "location" ]

[ "uint64_t", "read_uint64", "(", "byte", "*", "ptr", ")", "{", "uint32_t", "ret", "=", "0", ";", "int", "len", "=", "8", ";", "while", "(", "len", "--", ")", "ret", "+=", "(", "*", "ptr", "++", "<<", "(", "8", "*", "len", ")", ")", ";", "return", "ret", ";", "}" ]

[ "Reads", "and", "returns", "big", "-", "endian", "uint32_t", "at", "a", "given", "memory", "location" ]

[]

[ { "param": "ptr", "type": "byte" } ]

[ "Apache-2.0" ]

[ "Reads", "and", "returns", "variable", "integer", "from", "given", "location", "as", "uint16_t", "Also", "returns", "the", "length", "of", "the", "varint" ]

[ "uint16_t", "read_vint16", "(", "byte", "*", "ptr", ",", "int8_t", "*", "vlen", ")", "{", "uint16_t", "ret", "=", "0", ";", "int8_t", "len", "=", "3", ";", "do", "{", "ret", "<<=", "7", ";", "ret", "+=", "*", "ptr", "&", "0x7F", ";", "len", "--", ";", "}", "while", "(", "(", "*", "ptr", "++", "&", "0x80", ")", "==", "0x80", "&&", "len", ")", ";", "if", "(", "vlen", ")", "*", "vlen", "=", "3", "-", "len", ";", "return", "ret", ";", "}" ]

[ "Reads", "and", "returns", "variable", "integer", "from", "given", "location", "as", "uint16_t", "Also", "returns", "the", "length", "of", "the", "varint" ]

[ "// read max 3 bytes" ]

[ { "param": "ptr", "type": "byte" }, { "param": "vlen", "type": "int8_t" } ]

[ "Apache-2.0" ]

[ "Reads", "and", "returns", "variable", "integer", "from", "given", "location", "as", "uint32_t", "Also", "returns", "the", "length", "of", "the", "varint" ]

[ "uint32_t", "read_vint32", "(", "byte", "*", "ptr", ",", "int8_t", "*", "vlen", ")", "{", "uint32_t", "ret", "=", "0", ";", "int8_t", "len", "=", "5", ";", "do", "{", "ret", "<<=", "7", ";", "ret", "+=", "*", "ptr", "&", "0x7F", ";", "len", "--", ";", "}", "while", "(", "(", "*", "ptr", "++", "&", "0x80", ")", "==", "0x80", "&&", "len", ")", ";", "if", "(", "vlen", ")", "*", "vlen", "=", "5", "-", "len", ";", "return", "ret", ";", "}" ]

[ "Reads", "and", "returns", "variable", "integer", "from", "given", "location", "as", "uint32_t", "Also", "returns", "the", "length", "of", "the", "varint" ]

[ "// read max 5 bytes" ]

[ { "param": "ptr", "type": "byte" }, { "param": "vlen", "type": "int8_t" } ]

[ "Apache-2.0" ]

[ "Converts", "float", "to", "Sqlite", "'", "s", "Big", "-", "endian", "double" ]

[ "int64_t", "float_to_double", "(", "const", "void", "*", "val", ")", "{", "uint32_t", "bytes", "=", "*", "(", "(", "uint32_t", "*", ")", "val", ")", ";", "uint8_t", "exp8", "=", "(", "bytes", ">>", "23", ")", "&", "0xFF", ";", "uint16_t", "exp11", "=", "exp8", ";", "if", "(", "exp11", "!=", "0", ")", "{", "if", "(", "exp11", "<", "127", ")", "exp11", "=", "1023", "-", "(", "127", "-", "exp11", ")", ";", "else", "exp11", "=", "1023", "+", "(", "exp11", "-", "127", ")", ";", "}", "return", "(", "(", "int64_t", ")", "(", "bytes", ">>", "31", ")", "<<", "63", ")", "|", "(", "(", "int64_t", ")", "exp11", "<<", "52", ")", "|", "(", "(", "int64_t", ")", "(", "bytes", "&", "0x7FFFFF", ")", "<<", "(", "52", "-", "23", ")", ")", ";", "}" ]

[ "Converts", "float", "to", "Sqlite", "'", "s", "Big", "-", "endian", "double" ]

[]

[ { "param": "val", "type": "void" } ]

[ "Apache-2.0" ]

[ "Returns", "position", "of", "last", "record", ".", "Creates", "one", "if", "no", "record", "found", "." ]

[ "uint16_t", "acquire_last_pos", "(", "struct", "dblog_write_context", "*", "wctx", ",", "byte", "*", "ptr", ")", "{", "uint16_t", "last_pos", "=", "read_uint16", "(", "ptr", "+", "5", ")", ";", "if", "(", "last_pos", "==", "0", ")", "{", "dblog_append_empty_row", "(", "wctx", ")", ";", "last_pos", "=", "read_uint16", "(", "ptr", "+", "5", ")", ";", "}", "return", "last_pos", ";", "}" ]

[ "Returns", "position", "of", "last", "record", "." ]

[]

[ { "param": "wctx", "type": "struct dblog_write_context" }, { "param": "ptr", "type": "byte" } ]

[ "Apache-2.0" ]

[ "Writes", "Record", "length", "Row", "ID", "and", "Header", "length", "at", "given", "location", "No", "corruption", "checking", "because", "no", "unreliable", "source" ]

[ "void", "write_rec_len_rowid_hdr_len", "(", "byte", "*", "ptr", ",", "uint16_t", "rec_len", ",", "uint32_t", "rowid", ",", "uint16_t", "hdr_len", ")", "{", "*", "ptr", "++", "=", "0x80", "+", "(", "rec_len", ">>", "14", ")", ";", "*", "ptr", "++", "=", "0x80", "+", "(", "(", "rec_len", ">>", "7", ")", "&", "0x7F", ")", ";", "*", "ptr", "++", "=", "rec_len", "&", "0x7F", ";", "ptr", "+=", "write_vint32", "(", "ptr", ",", "rowid", ")", ";", "*", "ptr", "++", "=", "0x80", "+", "(", "hdr_len", ">>", "7", ")", ";", "*", "ptr", "=", "hdr_len", "&", "0x7F", ";", "}" ]

[ "Writes", "Record", "length", "Row", "ID", "and", "Header", "length", "at", "given", "location", "No", "corruption", "checking", "because", "no", "unreliable", "source" ]

[ "// write record len", "// write row id", "// write header len" ]

[ { "param": "ptr", "type": "byte" }, { "param": "rec_len", "type": "uint16_t" }, { "param": "rowid", "type": "uint32_t" }, { "param": "hdr_len", "type": "uint16_t" } ]

[ "Apache-2.0" ]

[ "Checks", "or", "calculates", "3", "checksums", ":", "1", ".", "Header", "checksum", "which", "is", "for", "page", "header", "and", "last", "rowid", "2", ".", "Checksum", "of", "first", "record", "3", "." ]

[ "int", "check_sums", "(", "byte", "*", "buf", ",", "int32_t", "page_size", ",", "int", "calc_or_check", ")", "{", "if", "(", "*", "buf", "==", "5", ")", "return", "DBLOG_RES_OK", ";", "if", "(", "*", "buf", "==", "13", ")", "{", "int8_t", "vlen", ";", "uint8_t", "chk_sum", "=", "0", ";", "uint16_t", "i", "=", "0", ";", "uint16_t", "end", "=", "8", ";", "while", "(", "i", "<", "end", ")", "chk_sum", "+=", "buf", "[", "i", "++", "]", ";", "uint16_t", "last_pos", "=", "read_uint16", "(", "buf", "+", "5", ")", ";", "i", "=", "last_pos", ";", "end", "=", "i", "+", "LEN_OF_REC_LEN", ";", "read_vint32", "(", "buf", "+", "end", ",", "&", "vlen", ")", ";", "end", "+=", "vlen", ";", "while", "(", "i", "<", "end", ")", "chk_sum", "+=", "buf", "[", "i", "++", "]", ";", "if", "(", "calc_or_check", "==", "0", ")", "buf", "[", "last_pos", "-", "1", "]", "=", "chk_sum", ";", "else", "if", "(", "calc_or_check", "==", "1", ")", "{", "if", "(", "buf", "[", "last_pos", "-", "1", "]", "!=", "chk_sum", ")", "return", "DBLOG_RES_INV_CHKSUM", ";", "return", "DBLOG_RES_OK", ";", "}", "i", "=", "end", ";", "end", "+=", "read_vint16", "(", "buf", "+", "end", "-", "vlen", "-", "LEN_OF_REC_LEN", ",", "&", "vlen", ")", ";", "while", "(", "i", "<", "end", ")", "chk_sum", "+=", "buf", "[", "i", "++", "]", ";", "if", "(", "calc_or_check", "==", "0", ")", "buf", "[", "last_pos", "-", "2", "]", "=", "chk_sum", ";", "else", "if", "(", "calc_or_check", "==", "2", ")", "{", "if", "(", "buf", "[", "last_pos", "-", "2", "]", "!=", "chk_sum", ")", "return", "DBLOG_RES_INV_CHKSUM", ";", "return", "DBLOG_RES_OK", ";", "}", "i", "=", "end", ";", "end", "=", "page_size", ";", "while", "(", "i", "<", "end", ")", "chk_sum", "+=", "buf", "[", "i", "++", "]", ";", "i", "=", "8", ";", "end", "=", "i", "+", "read_uint16", "(", "buf", "+", "3", ")", "*", "2", ";", "while", "(", "i", "<", "end", ")", "chk_sum", "+=", "buf", "[", "i", "++", "]", ";", "if", "(", "calc_or_check", "==", "0", ")", "buf", "[", "last_pos", "-", "3", "]", "=", "chk_sum", ";", "else", "{", "if", "(", "buf", "[", "last_pos", "-", "3", "]", "!=", "chk_sum", ")", "return", "DBLOG_RES_INV_CHKSUM", ";", "}", "}", "else", "{", "int", "i", "=", "0", ";", "uint8_t", "chk_sum", "=", "0", ";", "while", "(", "i", "<", "page_size", ")", "chk_sum", "+=", "buf", "[", "i", "++", "]", ";", "chk_sum", "-=", "buf", "[", "69", "]", ";", "if", "(", "calc_or_check", ")", "buf", "[", "69", "]", "=", "chk_sum", ";", "else", "{", "if", "(", "buf", "[", "69", "]", "!=", "chk_sum", ")", "return", "DBLOG_RES_ERR", ";", "}", "}", "return", "DBLOG_RES_OK", ";", "}" ]

[ "Checks", "or", "calculates", "3", "checksums", ":", "1", "." ]

[ "// no need checksum for internal pages", "// Header checksum", "// Header checksum", "// First record checksum", "// Page checksum", "// Page checksum", "// Assume first page" ]

[ { "param": "buf", "type": "byte" }, { "param": "page_size", "type": "int32_t" }, { "param": "calc_or_check", "type": "int" } ]

[ "Apache-2.0" ]

[ "Writes", "a", "page", "to", "disk", "using", "the", "given", "callback", "function" ]

[ "int", "write_page", "(", "struct", "dblog_write_context", "*", "wctx", ",", "uint32_t", "page_no", ",", "int32_t", "page_size", ")", "{", "check_sums", "(", "wctx", "->", "buf", ",", "page_size", ",", "0", ")", ";", "if", "(", "(", "wctx", "->", "write_fn", ")", "(", "wctx", ",", "wctx", "->", "buf", ",", "page_no", "*", "page_size", ",", "page_size", ")", "!=", "page_size", ")", "return", "DBLOG_RES_WRITE_ERR", ";", "return", "DBLOG_RES_OK", ";", "}" ]

[ "Writes", "a", "page", "to", "disk", "using", "the", "given", "callback", "function" ]

[]

[ { "param": "wctx", "type": "struct dblog_write_context" }, { "param": "page_no", "type": "uint32_t" }, { "param": "page_size", "type": "int32_t" } ]

[ "Apache-2.0" ]

[ "Reads", "specified", "number", "of", "bytes", "from", "disk", "using", "the", "given", "callback", "function", "for", "Write", "context" ]

[ "int", "read_bytes_wctx", "(", "struct", "dblog_write_context", "*", "wctx", ",", "byte", "*", "buf", ",", "long", "pos", ",", "int32_t", "size", ")", "{", "if", "(", "(", "wctx", "->", "read_fn", ")", "(", "wctx", ",", "buf", ",", "pos", ",", "size", ")", "!=", "size", ")", "return", "DBLOG_RES_READ_ERR", ";", "return", "DBLOG_RES_OK", ";", "}" ]

[ "Reads", "specified", "number", "of", "bytes", "from", "disk", "using", "the", "given", "callback", "function", "for", "Write", "context" ]

[]

[ { "param": "wctx", "type": "struct dblog_write_context" }, { "param": "buf", "type": "byte" }, { "param": "pos", "type": "long" }, { "param": "size", "type": "int32_t" } ]

[ "Apache-2.0" ]

[ "Reads", "specified", "number", "of", "bytes", "from", "disk", "using", "the", "given", "callback", "function", "for", "Read", "context" ]

[ "int", "read_bytes_rctx", "(", "struct", "dblog_read_context", "*", "rctx", ",", "byte", "*", "buf", ",", "long", "pos", ",", "int32_t", "size", ")", "{", "if", "(", "(", "rctx", "->", "read_fn", ")", "(", "rctx", ",", "buf", ",", "pos", ",", "size", ")", "!=", "size", ")", "return", "DBLOG_RES_READ_ERR", ";", "return", "DBLOG_RES_OK", ";", "}" ]

[ "Reads", "specified", "number", "of", "bytes", "from", "disk", "using", "the", "given", "callback", "function", "for", "Read", "context" ]

[]

[ { "param": "rctx", "type": "struct dblog_read_context" }, { "param": "buf", "type": "byte" }, { "param": "pos", "type": "long" }, { "param": "size", "type": "int32_t" } ]

[ "Apache-2.0" ]

[ "Adds", "record", "to", "B", "-", "Tree", "inner", "table" ]

[ "int", "add_rec_to_inner_tbl", "(", "struct", "dblog_write_context", "*", "wctx", ",", "byte", "*", "parent_buf", ",", "uint32_t", "rowid", ",", "uint32_t", "cur_level_pos", ")", "{", "int32_t", "page_size", "=", "get_pagesize", "(", "wctx", "->", "page_size_exp", ")", ";", "uint16_t", "last_pos", "=", "read_uint16", "(", "parent_buf", "+", "5", ")", ";", "int", "rec_count", "=", "read_uint16", "(", "parent_buf", "+", "3", ")", "+", "1", ";", "byte", "rec_len", "=", "4", "+", "get_vlen_of_uint32", "(", "rowid", ")", ";", "if", "(", "last_pos", "==", "0", ")", "last_pos", "=", "page_size", "-", "rec_len", ";", "else", "{", "if", "(", "last_pos", "-", "rec_len", "<", "12", "+", "rec_count", "*", "2", "+", "get_vlen_of_uint32", "(", "rowid", ")", "+", "3", ")", "last_pos", "=", "0", ";", "else", "last_pos", "-=", "rec_len", ";", "}", "cur_level_pos", "++", ";", "if", "(", "last_pos", "&&", "rowid", ")", "{", "write_uint32", "(", "parent_buf", "+", "last_pos", ",", "cur_level_pos", ")", ";", "write_vint32", "(", "parent_buf", "+", "last_pos", "+", "4", ",", "rowid", ")", ";", "write_uint16", "(", "parent_buf", "+", "3", ",", "rec_count", "--", ")", ";", "write_uint16", "(", "parent_buf", "+", "12", "+", "rec_count", "*", "2", ",", "last_pos", ")", ";", "write_uint16", "(", "parent_buf", "+", "5", ",", "last_pos", ")", ";", "}", "else", "{", "write_uint32", "(", "parent_buf", "+", "8", ",", "cur_level_pos", ")", ";", "rec_count", "--", ";", "write_vint32", "(", "parent_buf", "+", "12", "+", "rec_count", "*", "2", ",", "rowid", ")", ";", "return", "1", ";", "}", "return", "DBLOG_RES_OK", ";", "}" ]

[ "Adds", "record", "to", "B", "-", "Tree", "inner", "table" ]

[ "// 3 is for checksum", "// No corruption checking because no unreliable source" ]

[ { "param": "wctx", "type": "struct dblog_write_context" }, { "param": "parent_buf", "type": "byte" }, { "param": "rowid", "type": "uint32_t" }, { "param": "cur_level_pos", "type": "uint32_t" } ]

[ "Apache-2.0" ]

[ "Writes", "data", "into", "buffer", "to", "form", "first", "page", "of", "Sqlite", "db" ]

[ "int", "form_page1", "(", "struct", "dblog_write_context", "*", "wctx", ",", "char", "*", "table_name", ",", "char", "*", "table_script", ")", "{", "if", "(", "wctx", "->", "page_size_exp", "<", "9", "||", "wctx", "->", "page_size_exp", ">", "16", ")", "return", "DBLOG_RES_INV_PAGE_SZ", ";", "byte", "*", "buf", "=", "(", "byte", "*", ")", "wctx", "->", "buf", ";", "int32_t", "page_size", "=", "get_pagesize", "(", "wctx", "->", "page_size_exp", ")", ";", "wctx", "->", "cur_write_rowid", "=", "0", ";", "memcpy", "(", "buf", ",", "dblog_sig", ",", "16", ")", ";", "write_uint16", "(", "buf", "+", "16", ",", "page_size", "==", "65536", "?", "1", ":", "(", "uint16_t", ")", "page_size", ")", ";", "buf", "[", "18", "]", "=", "1", ";", "buf", "[", "19", "]", "=", "1", ";", "buf", "[", "20", "]", "=", "wctx", "->", "page_resv_bytes", ";", "buf", "[", "21", "]", "=", "64", ";", "buf", "[", "22", "]", "=", "32", ";", "buf", "[", "23", "]", "=", "32", ";", "memset", "(", "buf", "+", "24", ",", "'", "\\0", "'", ",", "20", ")", ";", "write_uint32", "(", "buf", "+", "28", ",", "2", ")", ";", "write_uint32", "(", "buf", "+", "44", ",", "4", ")", ";", "memset", "(", "buf", "+", "48", ",", "'", "\\0", "'", ",", "8", ")", ";", "write_uint32", "(", "buf", "+", "56", ",", "1", ")", ";", "write_uint32", "(", "buf", "+", "60", ",", "0", ")", ";", "write_uint32", "(", "buf", "+", "64", ",", "0", ")", ";", "write_uint32", "(", "buf", "+", "68", ",", "0xA5000000", ")", ";", "memset", "(", "buf", "+", "72", ",", "'", "\\0", "'", ",", "20", ")", ";", "write_uint32", "(", "buf", "+", "92", ",", "105", ")", ";", "write_uint32", "(", "buf", "+", "96", ",", "3016000", ")", ";", "memset", "(", "buf", "+", "100", ",", "'", "\\0", "'", ",", "page_size", "-", "100", ")", ";", "init_bt_tbl_leaf", "(", "buf", "+", "100", ")", ";", "int", "orig_col_count", "=", "wctx", "->", "col_count", ";", "wctx", "->", "cur_write_page", "=", "0", ";", "wctx", "->", "col_count", "=", "5", ";", "dblog_append_empty_row", "(", "wctx", ")", ";", "dblog_set_col_val", "(", "wctx", ",", "0", ",", "DBLOG_TYPE_TEXT", ",", "\"", "\"", ",", "5", ")", ";", "if", "(", "table_name", "==", "NULL", ")", "table_name", "=", "default_table_name", ";", "dblog_set_col_val", "(", "wctx", ",", "1", ",", "DBLOG_TYPE_TEXT", ",", "table_name", ",", "strlen", "(", "table_name", ")", ")", ";", "dblog_set_col_val", "(", "wctx", ",", "2", ",", "DBLOG_TYPE_TEXT", ",", "table_name", ",", "strlen", "(", "table_name", ")", ")", ";", "int32_t", "root_page", "=", "2", ";", "dblog_set_col_val", "(", "wctx", ",", "3", ",", "DBLOG_TYPE_INT", ",", "&", "root_page", ",", "4", ")", ";", "if", "(", "table_script", ")", "{", "uint16_t", "script_len", "=", "strlen", "(", "table_script", ")", ";", "if", "(", "script_len", ">", "page_size", "-", "100", "-", "wctx", "->", "page_resv_bytes", "-", "8", "-", "10", ")", "return", "DBLOG_RES_TOO_LONG", ";", "dblog_set_col_val", "(", "wctx", ",", "4", ",", "DBLOG_TYPE_TEXT", ",", "table_script", ",", "script_len", ")", ";", "}", "else", "{", "int", "table_name_len", "=", "strlen", "(", "table_name", ")", ";", "int", "script_len", "=", "(", "13", "+", "table_name_len", "+", "2", "+", "5", "*", "orig_col_count", ")", ";", "if", "(", "script_len", ">", "page_size", "-", "100", "-", "wctx", "->", "page_resv_bytes", "-", "8", "-", "10", ")", "return", "DBLOG_RES_TOO_LONG", ";", "dblog_set_col_val", "(", "wctx", ",", "4", ",", "DBLOG_TYPE_TEXT", ",", "buf", "+", "110", ",", "script_len", ")", ";", "byte", "*", "script_pos", "=", "buf", "+", "page_size", "-", "buf", "[", "20", "]", "-", "script_len", ";", "memcpy", "(", "script_pos", ",", "\"", "\"", ",", "13", ")", ";", "script_pos", "+=", "13", ";", "memcpy", "(", "script_pos", ",", "table_name", ",", "table_name_len", ")", ";", "script_pos", "+=", "table_name_len", ";", "*", "script_pos", "++", "=", "'", "'", ";", "*", "script_pos", "++", "=", "'", "'", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "orig_col_count", ";", ")", "{", "i", "++", ";", "*", "script_pos", "++", "=", "'", "'", ";", "*", "script_pos", "++", "=", "'", "'", "+", "(", "i", "<", "100", "?", "0", ":", "(", "i", "/", "100", ")", ")", ";", "*", "script_pos", "++", "=", "'", "'", "+", "(", "i", "<", "10", "?", "0", ":", "(", "(", "i", "<", "100", "?", "i", ":", "i", "-", "100", ")", "/", "10", ")", ")", ";", "*", "script_pos", "++", "=", "'", "'", "+", "(", "i", "%", "10", ")", ";", "*", "script_pos", "++", "=", "(", "i", "==", "orig_col_count", "?", "'", "'", ":", "'", "'", ")", ";", "}", "}", "int", "res", "=", "write_page", "(", "wctx", ",", "0", ",", "page_size", ")", ";", "if", "(", "res", ")", "return", "res", ";", "wctx", "->", "col_count", "=", "orig_col_count", ";", "wctx", "->", "cur_write_page", "=", "1", ";", "wctx", "->", "cur_write_rowid", "=", "0", ";", "init_bt_tbl_leaf", "(", "wctx", "->", "buf", ")", ";", "wctx", "->", "state", "=", "DBLOG_ST_WRITE_PENDING", ";", "return", "DBLOG_RES_OK", ";", "}" ]

[ "Writes", "data", "into", "buffer", "to", "form", "first", "page", "of", "Sqlite", "db" ]

[ "// 100 byte header - refer https://www.sqlite.org/fileformat.html", "//memcpy(buf, \"SQLite format 3\\0\", 16);", "//write_uint32(buf + 24, 0);", "//write_uint32(buf + 28, 0);", "//write_uint32(buf + 32, 0);", "//write_uint32(buf + 36, 0);", "//write_uint32(buf + 40, 0);", "// Set to zero, above 5", "// TODO: Update during finalize", "//write_uint16(buf + 48, 0);", "//write_uint16(buf + 52, 0);", "// Set to zero, above 2", "// User version initially 0, set to table leaf count", "// used to locate last leaf page for binary search", "// and move to last page.", "// App ID - set to 0xA5xxxxxx where A5 is signature", "// last 5 bits = wctx->max_pages_exp - set to 0 currently", "// till it is implemented", "// reserved space", "// Set remaing page to zero", "// master table b-tree", "// write table script record" ]

[ { "param": "wctx", "type": "struct dblog_write_context" }, { "param": "table_name", "type": "char" }, { "param": "table_script", "type": "char" } ]

[ "Apache-2.0" ]

[ "Checks", "possible", "signatures", "that", "a", "file", "can", "have" ]

[ "int", "check_signature", "(", "byte", "*", "buf", ")", "{", "if", "(", "memcmp", "(", "buf", ",", "dblog_sig", ",", "16", ")", "&&", "memcmp", "(", "buf", ",", "sqlite_sig", ",", "16", ")", ")", "return", "DBLOG_RES_INVALID_SIG", ";", "if", "(", "buf", "[", "68", "]", "!=", "0xA5", ")", "return", "DBLOG_RES_INVALID_SIG", ";", "return", "DBLOG_RES_OK", ";", "}" ]

[ "Checks", "possible", "signatures", "that", "a", "file", "can", "have" ]

[]

[ { "param": "buf", "type": "byte" } ]

[ "Apache-2.0" ]

[ "Checks", "space", "for", "appending", "new", "row", "If", "space", "not", "available", "writes", "current", "buffer", "to", "disk", "and", "initializes", "buffer", "as", "new", "page" ]

[ "uint16_t", "make_space_for_new_row", "(", "struct", "dblog_write_context", "*", "wctx", ",", "int32_t", "page_size", ",", "uint16_t", "len_of_rec_len_rowid", ",", "uint16_t", "new_rec_len", ")", "{", "byte", "*", "ptr", "=", "wctx", "->", "buf", "+", "(", "wctx", "->", "buf", "[", "0", "]", "==", "13", "?", "0", ":", "100", ")", ";", "uint16_t", "last_pos", "=", "read_uint16", "(", "ptr", "+", "5", ")", ";", "if", "(", "last_pos", "&&", "last_pos", ">", "page_size", "-", "wctx", "->", "page_resv_bytes", "-", "7", ")", "return", "0", ";", "int", "rec_count", "=", "read_uint16", "(", "ptr", "+", "3", ")", "+", "1", ";", "if", "(", "last_pos", "&&", "rec_count", "*", "2", "+", "8", ">=", "last_pos", ")", "return", "0", ";", "if", "(", "last_pos", "==", "0", ")", "last_pos", "=", "page_size", "-", "wctx", "->", "page_resv_bytes", ";", "if", "(", "last_pos", "&&", "last_pos", "<", "(", "(", "ptr", "-", "wctx", "->", "buf", ")", "+", "9", "+", "CHKSUM_LEN", "+", "(", "rec_count", "*", "2", ")", "+", "new_rec_len", "+", "len_of_rec_len_rowid", ")", ")", "{", "int", "res", "=", "write_page", "(", "wctx", ",", "wctx", "->", "cur_write_page", ",", "page_size", ")", ";", "if", "(", "res", ")", "return", "res", ";", "wctx", "->", "cur_write_page", "++", ";", "init_bt_tbl_leaf", "(", "wctx", "->", "buf", ")", ";", "last_pos", "=", "page_size", "-", "wctx", "->", "page_resv_bytes", "-", "new_rec_len", "-", "len_of_rec_len_rowid", ";", "}", "else", "{", "last_pos", "-=", "new_rec_len", ";", "last_pos", "-=", "len_of_rec_len_rowid", ";", "}", "return", "last_pos", ";", "}" ]

[ "Checks", "space", "for", "appending", "new", "row", "If", "space", "not", "available", "writes", "current", "buffer", "to", "disk", "and", "initializes", "buffer", "as", "new", "page" ]

[ "// corruption", "// corruption" ]

[ { "param": "wctx", "type": "struct dblog_write_context" }, { "param": "page_size", "type": "int32_t" }, { "param": "len_of_rec_len_rowid", "type": "uint16_t" }, { "param": "new_rec_len", "type": "uint16_t" } ]

[ "Apache-2.0" ]

[ "Writes", "given", "value", "at", "given", "pointer", "in", "Sqlite", "format" ]

[ "uint16_t", "write_data", "(", "byte", "*", "data_ptr", ",", "int", "type", ",", "const", "void", "*", "val", ",", "uint16_t", "len", ")", "{", "if", "(", "val", "==", "NULL", ")", "return", "0", ";", "if", "(", "type", "==", "DBLOG_TYPE_INT", ")", "{", "switch", "(", "len", ")", "{", "case", "1", ":", "write_uint8", "(", "data_ptr", ",", "*", "(", "(", "int8_t", "*", ")", "val", ")", ")", ";", "break", ";", "case", "2", ":", "write_uint16", "(", "data_ptr", ",", "*", "(", "(", "int16_t", "*", ")", "val", ")", ")", ";", "break", ";", "case", "4", ":", "write_uint32", "(", "data_ptr", ",", "*", "(", "(", "int32_t", "*", ")", "val", ")", ")", ";", "break", ";", "case", "8", ":", "write_uint64", "(", "data_ptr", ",", "*", "(", "(", "int64_t", "*", ")", "val", ")", ")", ";", "break", ";", "}", "}", "else", "if", "(", "type", "==", "DBLOG_TYPE_REAL", "&&", "len", "==", "4", ")", "{", "uint64_t", "bytes64", "=", "float_to_double", "(", "val", ")", ";", "write_uint64", "(", "data_ptr", ",", "bytes64", ")", ";", "len", "=", "8", ";", "}", "else", "if", "(", "type", "==", "DBLOG_TYPE_REAL", "&&", "len", "==", "8", ")", "{", "uint64_t", "bytes", "=", "*", "(", "(", "uint64_t", "*", ")", "val", ")", ";", "write_uint64", "(", "data_ptr", ",", "bytes", ")", ";", "}", "else", "memcpy", "(", "data_ptr", ",", "val", ",", "len", ")", ";", "return", "len", ";", "}" ]

[ "Writes", "given", "value", "at", "given", "pointer", "in", "Sqlite", "format" ]

[ "// Assumes float is represented in IEEE-754 format", "// Assumes double is represented in IEEE-754 format" ]

[ { "param": "data_ptr", "type": "byte" }, { "param": "type", "type": "int" }, { "param": "val", "type": "void" }, { "param": "len", "type": "uint16_t" } ]

[ "Apache-2.0" ]

[ "Returns", "the", "Row", "ID", "of", "the", "last", "record", "stored", "in", "the", "given", "leaf", "page", "Reads", "the", "buffer", "part", "by", "part", "to", "avoid", "reading", "entire", "buffer", "into", "memory", "to", "support", "low", "memory", "systems", "(", "2kb", "ram", ")", "The", "underlying", "callback", "function", "hopefully", "optimizes", "repeated", "IO" ]

[ "int", "read_last_val", "(", "struct", "dblog_read_context", "*", "rctx", ",", "uint32_t", "pos", ",", "int32_t", "page_size", ",", "int", "col_idx", ",", "byte", "*", "val_at", ",", "int", "val_len", ",", "uint32_t", "*", "out_col_type", ",", "uint16_t", "*", "out_rec_pos", ",", "byte", "is_rowid", ")", "{", "byte", "src_buf", "[", "12", "]", ";", "int", "res", "=", "read_bytes_rctx", "(", "rctx", ",", "src_buf", ",", "pos", "*", "page_size", ",", "12", ")", ";", "if", "(", "res", ")", "return", "res", ";", "if", "(", "*", "src_buf", "!=", "13", ")", "return", "DBLOG_RES_MALFORMED", ";", "*", "out_rec_pos", "=", "read_uint16", "(", "src_buf", "+", "3", ")", "-", "1", ";", "uint16_t", "last_pos", "=", "read_uint16", "(", "src_buf", "+", "5", ")", ";", "res", "=", "read_bytes_rctx", "(", "rctx", ",", "src_buf", ",", "pos", "*", "page_size", "+", "last_pos", ",", "12", ")", ";", "if", "(", "res", ")", "return", "res", ";", "int8_t", "vint_len", ";", "uint32_t", "u32", "=", "read_vint32", "(", "src_buf", "+", "3", ",", "&", "vint_len", ")", ";", "if", "(", "is_rowid", ")", "*", "out_col_type", "=", "u32", ";", "else", "{", "uint16_t", "rec_len", "=", "read_vint16", "(", "src_buf", ",", "NULL", ")", "+", "vint_len", "+", "LEN_OF_REC_LEN", ";", "byte", "rec_buf", "[", "rec_len", "]", ";", "res", "=", "read_bytes_rctx", "(", "rctx", ",", "rec_buf", ",", "pos", "*", "page_size", "+", "last_pos", ",", "rec_len", ")", ";", "if", "(", "res", ")", "return", "res", ";", "uint16_t", "hdr_len", ";", "byte", "*", "data_ptr", ";", "byte", "*", "hdr_ptr", "=", "locate_column", "(", "rec_buf", ",", "col_idx", ",", "&", "data_ptr", ",", "&", "rec_len", ",", "&", "hdr_len", ",", "rec_len", ")", ";", "if", "(", "!", "hdr_ptr", ")", "return", "DBLOG_RES_MALFORMED", ";", "*", "out_col_type", "=", "read_vint32", "(", "hdr_ptr", ",", "&", "vint_len", ")", ";", "u32", "=", "dblog_derive_data_len", "(", "*", "out_col_type", ")", ";", "if", "(", "u32", ">", "val_len", ")", "u32", "=", "val_len", ";", "memcpy", "(", "val_at", ",", "data_ptr", ",", "u32", ")", ";", "}", "return", "DBLOG_RES_OK", ";", "}" ]

[ "Returns", "the", "Row", "ID", "of", "the", "last", "record", "stored", "in", "the", "given", "leaf", "page", "Reads", "the", "buffer", "part", "by", "part", "to", "avoid", "reading", "entire", "buffer", "into", "memory", "to", "support", "low", "memory", "systems", "(", "2kb", "ram", ")", "The", "underlying", "callback", "function", "hopefully", "optimizes", "repeated", "IO" ]

[]

[ { "param": "rctx", "type": "struct dblog_read_context" }, { "param": "pos", "type": "uint32_t" }, { "param": "page_size", "type": "int32_t" }, { "param": "col_idx", "type": "int" }, { "param": "val_at", "type": "byte" }, { "param": "val_len", "type": "int" }, { "param": "out_col_type", "type": "uint32_t" }, { "param": "out_rec_pos", "type": "uint16_t" }, { "param": "is_rowid", "type": "byte" } ]

[ "Apache-2.0" ]

[ "Returns", "the", "Row", "ID", "of", "the", "record", "at", "given", "position" ]

[ "uint32_t", "read_rowid_at", "(", "struct", "dblog_read_context", "*", "rctx", ",", "uint32_t", "rec_pos", ")", "{", "int8_t", "vint_len", ";", "return", "read_vint32", "(", "rctx", "->", "buf", "+", "read_uint16", "(", "rctx", "->", "buf", "+", "(", "*", "rctx", "->", "buf", "==", "13", "?", "8", ":", "12", ")", "+", "rec_pos", "*", "2", ")", "+", "(", "*", "rctx", "->", "buf", "==", "13", "?", "LEN_OF_REC_LEN", ":", "4", ")", ",", "&", "vint_len", ")", ";", "}" ]

[ "Returns", "the", "Row", "ID", "of", "the", "record", "at", "given", "position" ]

[]

[ { "param": "rctx", "type": "struct dblog_read_context" }, { "param": "rec_pos", "type": "uint32_t" } ]

[ "Apache-2.0" ]

[ "compares", "two", "binary", "strings", "and", "returns", "k", "-", "k", "or", "0", "0", "meaning", "the", "two", "are", "identical", ".", "If", "not", "k", "is", "length", "that", "matches" ]

[ "int", "compare_bin", "(", "const", "byte", "*", "v1", ",", "byte", "len1", ",", "const", "byte", "*", "v2", ",", "byte", "len2", ")", "{", "int", "k", "=", "0", ";", "int", "lim", "=", "(", "len2", "<", "len1", "?", "len2", ":", "len1", ")", ";", "while", "(", "k", "<", "lim", ")", "{", "byte", "c1", "=", "v1", "[", "k", "]", ";", "byte", "c2", "=", "v2", "[", "k", "]", ";", "k", "++", ";", "if", "(", "c1", "<", "c2", ")", "return", "-", "k", ";", "else", "if", "(", "c1", ">", "c2", ")", "return", "k", ";", "}", "if", "(", "len1", "==", "len2", ")", "return", "0", ";", "k", "++", ";", "return", "(", "len1", "<", "len2", "?", "-", "k", ":", "k", ")", ";", "}" ]

[ "compares", "two", "binary", "strings", "and", "returns", "k", "-", "k", "or", "0", "0", "meaning", "the", "two", "are", "identical", "." ]

[]

[ { "param": "v1", "type": "byte" }, { "param": "len1", "type": "byte" }, { "param": "v2", "type": "byte" }, { "param": "len2", "type": "byte" } ]

[ "Apache-2.0" ]

[ "Converts", "any", "type", "of", "integer", "to", "int64", "for", "comparison" ]

[ "int64_t", "convert_to_i64", "(", "byte", "*", "val", ",", "int", "len", ",", "byte", "is_big_endian", ")", "{", "int64_t", "ival_at", "=", "0", ";", "switch", "(", "len", ")", "{", "case", "4", ":", "{", "uint32_t", "u32_val_at", "=", "(", "is_big_endian", "?", "read_uint32", "(", "val", ")", ":", "*", "(", "(", "uint32_t", "*", ")", "val", ")", ")", ";", "if", "(", "u32_val_at", "&", "0x80000000", ")", "{", "ival_at", "=", "0xFFFFFFFF", "-", "u32_val_at", ";", "ival_at", "=", "0xFFFFFFFFFFFFFFFF", "-", "ival_at", ";", "}", "else", "ival_at", "=", "u32_val_at", ";", "break", ";", "}", "case", "2", ":", "{", "uint16_t", "u16_val_at", "=", "(", "is_big_endian", "?", "read_uint16", "(", "val", ")", ":", "*", "(", "(", "uint16_t", "*", ")", "val", ")", ")", ";", "ival_at", "=", "u16_val_at", "&", "0x7FFF", ";", "if", "(", "u16_val_at", "&", "0x8000", ")", "{", "ival_at", "=", "0xFFFF", "-", "u16_val_at", ";", "ival_at", "=", "0xFFFFFFFFFFFFFFFF", "-", "ival_at", ";", "}", "else", "ival_at", "=", "u16_val_at", ";", "break", ";", "}", "case", "6", ":", "case", "8", ":", "ival_at", "=", "(", "is_big_endian", "?", "read_uint64", "(", "val", ")", ":", "*", "(", "(", "int64_t", "*", ")", "val", ")", ")", ";", "break", ";", "case", "1", ":", "{", "uint8_t", "u8_val_at", "=", "(", "is_big_endian", "?", "read_uint8", "(", "val", ")", ":", "*", "(", "(", "uint8_t", "*", ")", "val", ")", ")", ";", "ival_at", "=", "u8_val_at", "&", "0x7F", ";", "if", "(", "u8_val_at", "&", "0x80", ")", "{", "ival_at", "=", "0xFF", "-", "u8_val_at", ";", "ival_at", "=", "0xFFFFFFFFFFFFFFFF", "-", "ival_at", ";", "}", "else", "ival_at", "=", "u8_val_at", ";", "}", "}", "return", "ival_at", ";", "}" ]

[ "Converts", "any", "type", "of", "integer", "to", "int64", "for", "comparison" ]

[]

[ { "param": "val", "type": "byte" }, { "param": "len", "type": "int" }, { "param": "is_big_endian", "type": "byte" } ]

[ "Apache-2.0" ]

[ "Compare", "values", "for", "binary", "search", "and", "return", "1", "-", "1", "or", "0" ]

[ "int", "compare_values", "(", "byte", "*", "val_at", ",", "uint32_t", "u32_at", ",", "int", "val_type", ",", "void", "*", "val", ",", "uint16_t", "len", ",", "byte", "is_rowid", ")", "{", "if", "(", "is_rowid", ")", "return", "(", "u32_at", ">", "*", "(", "(", "uint32_t", "*", ")", "val", ")", "?", "1", ":", "u32_at", "<", "*", "(", "(", "uint32_t", "*", ")", "val", ")", "?", "-1", ":", "0", ")", ";", "switch", "(", "val_type", ")", "{", "case", "DBLOG_TYPE_INT", ":", "{", "int64_t", "ival_at", "=", "convert_to_i64", "(", "val_at", ",", "u32_at", ",", "1", ")", ";", "int64_t", "ival", "=", "convert_to_i64", "(", "val", ",", "len", ",", "0", ")", ";", "return", "ival_at", ">", "ival", "?", "1", ":", "(", "ival_at", "<", "ival", "?", "-1", ":", "0", ")", ";", "}", "case", "DBLOG_TYPE_REAL", ":", "if", "(", "(", "len", "!=", "4", "&&", "len", "!=", "8", ")", "||", "u32_at", "!=", "7", ")", "return", "DBLOG_RES_TYPE_MISMATCH", ";", "int64_t", "bytes64", ",", "bytes64_at", ";", "bytes64_at", "=", "read_uint64", "(", "val_at", ")", ";", "if", "(", "len", "==", "4", ")", "bytes64", "=", "float_to_double", "(", "val", ")", ";", "else", "bytes64", "=", "*", "(", "(", "int64_t", "*", ")", "val", ")", ";", "return", "(", "bytes64_at", ">", "bytes64", "?", "1", ":", "bytes64_at", "<", "bytes64", "?", "-1", ":", "0", ")", ";", "case", "DBLOG_TYPE_BLOB", ":", "case", "DBLOG_TYPE_TEXT", ":", "{", "uint32_t", "len_at", "=", "dblog_derive_data_len", "(", "u32_at", ")", ";", "int", "res", "=", "compare_bin", "(", "val_at", ",", "len_at", ",", "val", ",", "len", ")", ";", "return", "(", "res", ">", "0", "?", "1", ":", "(", "res", "<", "0", "?", "-1", ":", "0", ")", ")", ";", "}", "}", "return", "1", ";", "}" ]

[ "Compare", "values", "for", "binary", "search", "and", "return", "1", "-", "1", "or", "0" ]

[]

[ { "param": "val_at", "type": "byte" }, { "param": "u32_at", "type": "uint32_t" }, { "param": "val_type", "type": "int" }, { "param": "val", "type": "void" }, { "param": "len", "type": "uint16_t" }, { "param": "is_rowid", "type": "byte" } ]

[ "BSD-2-Clause" ]

[ "Computes", "the", "sphere", "(", "multi", "-", "dimensional", "parabola", ")", "function" ]

[ "int", "objfunc_sphere", "(", "int", "dim", ",", "double", "point", "[", "]", ",", "double", "*", "value", ",", "void", "*", "callback_data", ")", "{", "double", "work", "[", "dim", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "dim", ";", "i", "++", ")", "{", "work", "[", "i", "]", "=", "point", "[", "i", "]", "*", "point", "[", "i", "]", ";", "}", "*", "value", "=", "0.0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "dim", ";", "i", "++", ")", "{", "*", "value", "+=", "work", "[", "i", "]", ";", "}", "struct", "cbdata", "*", "cbdata", "=", "(", "struct", "cbdata", "*", ")", "callback_data", ";", "if", "(", "cbdata", "->", "data", "!=", "987", ")", "return", "cbdata", "->", "data", ";", "return", "0", ";", "}" ]

[ "Computes", "the", "sphere", "(", "multi", "-", "dimensional", "parabola", ")", "function" ]

[ "// Calculate the function value", "// Do something with the callback data", "// Return success" ]

[ { "param": "dim", "type": "int" }, { "param": "point", "type": "double" }, { "param": "value", "type": "double" }, { "param": "callback_data", "type": "void" } ]

[ "BSD-2-Clause" ]

[ "Computes", "the", "gradient", "of", "the", "sphere", "function" ]

[ "int", "objgrad_sphere", "(", "int", "dim", ",", "double", "point", "[", "]", ",", "double", "grad", "[", "]", ",", "void", "*", "callback_data", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "dim", ";", "i", "++", ")", "{", "grad", "[", "i", "]", "=", "2.0", "*", "point", "[", "i", "]", ";", "}", "struct", "cbdata", "*", "cbdata", "=", "(", "struct", "cbdata", "*", ")", "callback_data", ";", "if", "(", "cbdata", "->", "data", "!=", "987", ")", "return", "cbdata", "->", "data", ";", "return", "0", ";", "}" ]

[ "Computes", "the", "gradient", "of", "the", "sphere", "function" ]

[ "// Calculate the gradient value", "// Do something with the callback data", "// Return success" ]

[ { "param": "dim", "type": "int" }, { "param": "point", "type": "double" }, { "param": "grad", "type": "double" }, { "param": "callback_data", "type": "void" } ]

[ "MIT" ]

[ "hack", "cmep", "and", "install", "a", "code", "-", "exec", "framework", "in", "secure_kernel" ]

[ "static", "int", "cmep_init", "(", "int", "a0", ",", "int", "a1", ")", "{", "k_root", "*", "kroot", "=", "&", "g_kroot", ";", "int", "(", "*", "start_sm", ")", "(", "int", "priority", ",", "const", "char", "*", "sm", ",", "int", "unk2", ",", "int", "unk3", ",", "int", "unk4", ",", "int", "unk5", ",", "SceSblSmCommContext130", "*", "commctx", ",", "int", "*", "smctx", ")", "=", "KFUN", "(", "\"", "\"", ",", "0x6dc", "|", "1", ")", ";", "int", "(", "*", "call_sm", ")", "(", "int", "smctx", ",", "int", "cmd", ",", "int", "*", "smret", ",", "void", "*", "argva", ",", "uint32_t", "argsz", ")", "=", "KFUN", "(", "\"", "\"", ",", "0x190", "|", "1", ")", ";", "int", "(", "*", "stop_sm", ")", "(", "int", "smctx", ",", "uint32_t", "*", "ret8", ")", "=", "KFUN", "(", "\"", "\"", ",", "0x7e4", "|", "1", ")", ";", "if", "(", "!", "kroot", "||", "!", "start_sm", "||", "!", "call_sm", "||", "!", "stop_sm", ")", "return", "-1", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "int", "ctx", "=", "-1", ";", "SceSblSmCommContext130", "smcomm_ctx", ";", "kroot", "->", "memset", "(", "&", "smcomm_ctx", ",", "0", ",", "sizeof", "(", "smcomm_ctx", ")", ")", ";", "kroot", "->", "memcpy", "(", "smcomm_ctx", ".", "data0", ",", "ctx_130_data", ",", "0x90", ")", ";", "smcomm_ctx", ".", "pathId", "=", "2", ";", "smcomm_ctx", ".", "self_type", "=", "(", "smcomm_ctx", ".", "self_type", "&", "0xFFFFFFF0", ")", "|", "2", ";", "int", "ret", "=", "start_sm", "(", "0", ",", "\"", "\"", ",", "0", ",", "0", ",", "0", ",", "0", ",", "&", "smcomm_ctx", ",", "&", "ctx", ")", ";", "if", "(", "ret", "<", "0", ")", "return", "ret", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "kroot", "->", "memset", "(", "kroot", "->", "pac_dram", ",", "0", ",", "0x1000", ")", ";", "cmd_0x50002_t", "*", "cargs", "=", "kroot", "->", "pac_dram", ";", "cargs", "->", "use_lv2_mode_0", "=", "cargs", "->", "use_lv2_mode_1", "=", "0", ";", "cargs", "->", "list_count", "=", "3", ";", "cargs", "->", "total_count", "=", "1", ";", "cargs", "->", "list", ".", "lv1", "[", "0", "]", ".", "addr", "=", "cargs", "->", "list", ".", "lv1", "[", "1", "]", ".", "addr", "=", "(", "void", "*", ")", "0x50000000", ";", "cargs", "->", "list", ".", "lv1", "[", "0", "]", ".", "length", "=", "cargs", "->", "list", ".", "lv1", "[", "1", "]", ".", "length", "=", "0x10", ";", "cargs", "->", "list", ".", "lv1", "[", "2", "]", ".", "addr", "=", "0", ";", "cargs", "->", "list", ".", "lv1", "[", "2", "]", ".", "length", "=", "0x0080bd40", "-", "offsetof", "(", "heap_hdr_t", ",", "next", ")", ";", "int", "sm_ret", "=", "-1", ";", "ret", "=", "call_sm", "(", "ctx", ",", "0x50002", ",", "&", "sm_ret", ",", "cargs", ",", "sizeof", "(", "cmd_0x50002_t", ")", ")", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ",", "ret", ",", "sm_ret", ")", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "sm_ret", "=", "-1", ";", "uint32_t", "jmpbuf", "[", "16", "]", ";", "jmpbuf", "[", "0", "]", "=", "1", ";", "jmpbuf", "[", "1", "]", "=", "1", ";", "jmpbuf", "[", "2", "]", "=", "0x1f850000", ";", "jmpbuf", "[", "3", "]", "=", "0x1f850000", ";", "jmpbuf", "[", "4", "]", "=", "0x1f850000", ";", "ret", "=", "call_sm", "(", "ctx", ",", "0xd0002", ",", "&", "sm_ret", ",", "jmpbuf", ",", "64", ")", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ",", "ret", ",", "sm_ret", ")", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "kroot", "->", "memset", "(", "kroot", "->", "venezia_spram", ",", "0", ",", "0x300", ")", ";", "kroot", "->", "memcpy", "(", "kroot", "->", "venezia_spram", ",", "nmp_stage2", ",", "sizeof", "(", "nmp_stage2", ")", ")", ";", "kroot", "->", "memcpy", "(", "(", "kroot", "->", "venezia_spram", "+", "0x100", ")", ",", "inject_framework_nmp", ",", "sizeof", "(", "inject_framework_nmp", ")", ")", ";", "kroot", "->", "memcpy", "(", "(", "kroot", "->", "venezia_spram", "+", "0x200", ")", ",", "sk_framework_nmp", ",", "sizeof", "(", "sk_framework_nmp", ")", ")", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "sm_ret", "=", "-1", ";", "jmpbuf", "[", "0", "]", "=", "5042", ";", "ret", "=", "call_sm", "(", "ctx", ",", "0xd0002", ",", "&", "sm_ret", ",", "jmpbuf", ",", "64", ")", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ",", "ret", ",", "sm_ret", ")", ";", "if", "(", "ret", ")", "return", "-2", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "jmpbuf", "[", "0", "]", "=", "0", ";", "jmpbuf", "[", "1", "]", "=", "0", ";", "return", "stop_sm", "(", "ctx", ",", "jmpbuf", ")", ";", "}" ]

[ "hack", "cmep", "and", "install", "a", "code", "-", "exec", "framework", "in", "secure_kernel" ]

[ "// get funcs", "// laod update_service_sm", "// convert service 0xd0002", "// plant stage2 paddr in sm buffer", "// copy stage2 and custom code to 0x1f850000", "// run stage2", "// unload the sm" ]

[ { "param": "a0", "type": "int" }, { "param": "a1", "type": "int" } ]

[ "MIT" ]

[ "run", "custom", "cmep", "code", "using", "the", "secure_kernel", "framework" ]

[ "static", "int", "cmep_run", "(", "k_root", "*", "kroot", ",", "void", "*", "code", ",", "uint32_t", "size", ",", "uint32_t", "arg", ")", "{", "if", "(", "!", "kroot", "||", "!", "code", ")", "return", "-1", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "fm_nfo", "*", "fmnfo", "=", "kroot", "->", "venezia_spram", ";", "kroot", "->", "memset", "(", "fmnfo", ",", "0", ",", "sizeof", "(", "fm_nfo", ")", ")", ";", "if", "(", "size", ")", "{", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "kroot", "->", "memset", "(", "kroot", "->", "venezia_spram", "+", "0x20", ",", "0", ",", "0x300", ")", ";", "kroot", "->", "memcpy", "(", "kroot", "->", "venezia_spram", "+", "0x20", ",", "code", ",", "size", ")", ";", "fmnfo", "->", "codepaddr", "=", "0x1f850020", ";", "}", "else", "fmnfo", "->", "codepaddr", "=", "(", "uint32_t", ")", "code", ";", "fmnfo", "->", "magic", "=", "0x14ff", ";", "fmnfo", "->", "arg", "=", "arg", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "__asm", "(", "\"", "\"", ")", ";", "__asm", "(", "\"", "\"", ")", ";", "fmnfo", "->", "status", "=", "0x34", ";", "int", "ret", "=", "xsmc", "(", "0", ",", "0", ",", "0", ",", "0", ",", "0x13c", ")", ";", "__asm", "(", "\"", "\"", ")", ";", "__asm", "(", "\"", "\"", ")", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ",", "ret", ",", "fmnfo", "->", "status", ",", "fmnfo", "->", "resp", ")", ";", "return", "(", "fmnfo", "->", "status", "==", "0x69", ")", "?", "(", "int", ")", "fmnfo", "->", "resp", ":", "-2", ";", "}" ]

[ "run", "custom", "cmep", "code", "using", "the", "secure_kernel", "framework" ]

[]

[ { "param": "kroot", "type": "k_root" }, { "param": "code", "type": "void" }, { "param": "size", "type": "uint32_t" }, { "param": "arg", "type": "uint32_t" } ]

[ "MIT" ]

[ "construct", "the", "fake", "secure_kernel", ".", "enp", "@", "0x4c000000" ]

[ "static", "int", "brom_init", "(", "k_root", "*", "kroot", ")", "{", "if", "(", "!", "kroot", ")", "return", "-1", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "kroot", "->", "memset", "(", "kroot", "->", "tachyon_edram", ",", "0", ",", "0x200000", ")", ";", "kroot", "->", "memset", "(", "kroot", "->", "pac_dram", ",", "0", ",", "0x20000", ")", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "kroot", "->", "memcpy", "(", "kroot", "->", "pac_dram", ",", "secure_kernel_enp", ",", "0x40", ")", ";", "kroot", "->", "memcpy", "(", "kroot", "->", "pac_dram", "+", "0x300", ",", "brom_stage2", ",", "0x10", ")", ";", "kroot", "->", "memcpy", "(", "kroot", "->", "pac_dram", "+", "0x310", ",", "brom_framework_nmp", ",", "sizeof", "(", "brom_framework_nmp", ")", ")", ";", "kroot", "->", "memcpy", "(", "kroot", "->", "pac_dram", "+", "0x3E0", ",", "\"", "\\n", "\"", ",", "sizeof", "(", "\"", "\\n", "\"", ")", ")", ";", "*", "(", "uint32_t", "*", ")", "(", "kroot", "->", "pac_dram", "+", "4", ")", "=", "0x2c0", ";", "*", "(", "uint32_t", "*", ")", "(", "kroot", "->", "pac_dram", "+", "0x10", ")", "=", "-0x2c0", ";", "for", "(", "int", "skoff", "=", "0x400", ";", "skoff", "<", "(", "0x20000", "-", "4", ")", ";", "skoff", "-=", "-4", ")", "{", "*", "(", "uint32_t", "*", ")", "(", "kroot", "->", "pac_dram", "+", "skoff", ")", "=", "0xbffebffe", ";", "}", "*", "(", "uint16_t", "*", ")", "(", "kroot", "->", "pac_dram", "+", "0x400", ")", "=", "0xbf00", ";", "return", "0", ";", "}" ]

[ "construct", "the", "fake", "secure_kernel", ".", "enp", "@", "0x4c000000" ]

[ "// legit sk header and the bootrom payloads", "// buffer overflow", "// bra slide-back", "// bra brom_payload" ]

[ { "param": "kroot", "type": "k_root" } ]

[ "MIT" ]

[ "run", "code", "using", "the", "cmep", "bootrom", "framework" ]

[ "static", "int", "brom_run", "(", "k_root", "*", "kroot", ",", "void", "*", "code", ",", "uint32_t", "size", ",", "uint32_t", "arg", ",", "int", "wellcheck", ")", "{", "if", "(", "!", "kroot", "||", "!", "code", ")", "return", "-1", ";", "void", "(", "*", "wait", ")", "(", ")", "=", "(", "void", "*", ")", "KFUN", "(", "\"", "\"", ",", "0x2fc8", "|", "1", ")", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ",", "code", ",", "arg", ",", "size", ")", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ",", "*", "(", "uint32_t", "*", ")", "kroot", "->", "pac_dram", ",", "*", "(", "uint32_t", "*", ")", "(", "kroot", "->", "pac_dram", "+", "4", ")", ",", "*", "(", "uint32_t", "*", ")", "(", "kroot", "->", "pac_dram", "+", "8", ")", ",", "*", "(", "uint32_t", "*", ")", "(", "kroot", "->", "pac_dram", "+", "0xC", ")", ")", ";", "if", "(", "*", "(", "uint32_t", "*", ")", "kroot", "->", "pac_dram", "!=", "0xF00DF00D", ")", "{", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "return", "-3", ";", "}", "volatile", "fm_nfo", "*", "fmnfo", "=", "kroot", "->", "tachyon_edram", ";", "kroot", "->", "memset", "(", "(", "void", "*", ")", "fmnfo", ",", "0", ",", "sizeof", "(", "fm_nfo", ")", ")", ";", "if", "(", "size", ")", "{", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "kroot", "->", "memset", "(", "kroot", "->", "tachyon_edram", "+", "0x20", ",", "0", ",", "0x300", ")", ";", "kroot", "->", "memcpy", "(", "kroot", "->", "tachyon_edram", "+", "0x20", ",", "code", ",", "size", ")", ";", "fmnfo", "->", "codepaddr", "=", "0x1C000020", ";", "}", "else", "fmnfo", "->", "codepaddr", "=", "(", "uint32_t", ")", "code", ";", "fmnfo", "->", "magic", "=", "0x14ff", ";", "fmnfo", "->", "arg", "=", "arg", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "__asm", "(", "\"", "\"", ")", ";", "__asm", "(", "\"", "\"", ")", ";", "fmnfo", "->", "status", "=", "0x34", ";", "__asm", "(", "\"", "\"", ")", ";", "__asm", "(", "\"", "\"", ")", ";", "while", "(", "fmnfo", "->", "status", "!=", "0xAA", ")", "{", "if", "(", "wellcheck", ")", "{", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ",", "*", "(", "uint32_t", "*", ")", "(", "kroot", "->", "tachyon_edram", "+", "0x10", ")", ",", "*", "(", "uint32_t", "*", ")", "(", "kroot", "->", "tachyon_edram", "+", "0x14", ")", ")", ";", "wait", "(", "wellcheck", ")", ";", "}", "}", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ",", "fmnfo", "->", "status", ",", "fmnfo", "->", "resp", ")", ";", "return", "(", "fmnfo", "->", "status", "==", "0xAA", ")", "?", "(", "int", ")", "fmnfo", "->", "resp", ":", "-2", ";", "}" ]

[ "run", "code", "using", "the", "cmep", "bootrom", "framework" ]

[]

[ { "param": "kroot", "type": "k_root" }, { "param": "code", "type": "void" }, { "param": "size", "type": "uint32_t" }, { "param": "arg", "type": "uint32_t" }, { "param": "wellcheck", "type": "int" } ]

[ "MIT" ]

[ "PA", "memcpy", "using", "the", "brom", "framework" ]

[ "static", "int", "bromcpy", "(", "uint32_t", "dst", ",", "uint32_t", "src", ",", "uint32_t", "size", ",", "k_root", "*", "kroot", ")", "{", "if", "(", "!", "kroot", ")", "return", "-1", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ",", "size", ",", "src", ",", "dst", ")", ";", "kroot", "->", "memset", "(", "kroot", "->", "pac_dram", "+", "0x10", ",", "0", ",", "0x20000", "-", "0x10", ")", ";", "bromcpy_args", "*", "args", "=", "kroot", "->", "pac_dram", "+", "0x10", ";", "args", "->", "magic", "=", "0xF00DF00D", ";", "args", "->", "src", "=", "src", ";", "args", "->", "dst", "=", "dst", ";", "args", "->", "sz", "=", "size", ";", "uint32_t", "ret", "=", "brom_run", "(", "kroot", ",", "(", "void", "*", ")", "bromcpy_nmp", ",", "sizeof", "(", "bromcpy_nmp", ")", ",", "0x4C000010", ",", "0", ")", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ",", "ret", ")", ";", "if", "(", "(", "uint32_t", ")", "ret", "!=", "0xF00D600D", ")", "return", "-2", ";", "return", "0", ";", "}" ]

[ "PA", "memcpy", "using", "the", "brom", "framework" ]

[]

[ { "param": "dst", "type": "uint32_t" }, { "param": "src", "type": "uint32_t" }, { "param": "size", "type": "uint32_t" }, { "param": "kroot", "type": "k_root" } ]

[ "MIT" ]

[ "copy", "3", ".", "65", "second_loader", "to", "cmep", "memory", "using", "bootrom", "code", "exec", "framework" ]

[ "static", "int", "apply_fakeenv", "(", "void", "*", "sl", ",", "void", "*", "evh", ",", "uint32_t", "evh_size", ",", "k_root", "*", "kroot", ")", "{", "if", "(", "!", "kroot", "||", "!", "evh", ")", "return", "-1", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ",", "0xCE00", ")", ";", "kroot", "->", "memset", "(", "kroot", "->", "tachyon_edram", "+", "0x20000", ",", "0", ",", "0xCE00", ")", ";", "kroot", "->", "memcpy", "(", "kroot", "->", "tachyon_edram", "+", "0x20000", ",", "sl", ",", "0xCE00", ")", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "0xb0", ";", "i", "-=", "-4", ")", "{", "*", "(", "uint32_t", "*", ")", "(", "kroot", "->", "tachyon_edram", "+", "0x20000", "+", "i", ")", "=", "0x0400dd88", ";", "}", "kroot", "->", "memcpy", "(", "kroot", "->", "tachyon_edram", "+", "0x200b0", ",", "evh", ",", "evh_size", ")", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "int", "ret", "=", "bromcpy", "(", "0x00040000", ",", "0x1C020000", ",", "0x300", ",", "kroot", ")", ";", "if", "(", "ret", ")", "return", "ret", ";", "kroot", "->", "printf", "(", "\"", "\\n", "\"", ")", ";", "ret", "=", "bromcpy", "(", "0x00040400", ",", "0x1C020000", "+", "0x400", ",", "0xCE00", "-", "0x400", ",", "kroot", ")", ";", "if", "(", "ret", ")", "return", "ret", ";", "return", "0", ";", "}" ]

[ "copy", "3", ".", "65", "second_loader", "to", "cmep", "memory", "using", "bootrom", "code", "exec", "framework" ]

[]

[ { "param": "sl", "type": "void" }, { "param": "evh", "type": "void" }, { "param": "evh_size", "type": "uint32_t" }, { "param": "kroot", "type": "k_root" } ]

[ "MIT" ]

[ "Check", "manager", "magic", "and", "jump", "to", "it" ]

[ "void", "_start", "(", "u8_t", "handshake", ")", "{", "fm_nfo", "*", "fmnfo", "=", "(", "void", "*", ")", "0x1c000000", ";", "if", "(", "(", "fmnfo", "->", "magic", "==", "0x14FF", ")", "&&", "(", "fmnfo", "->", "status", "==", "0x34", ")", ")", "{", "fmnfo", "->", "status", "=", "0x69", ";", "u32_t", "(", "*", "ccode", ")", "(", "u32_t", "arg", ")", "=", "(", "void", "*", ")", "(", "fmnfo", "->", "codepaddr", ")", ";", "fmnfo", "->", "resp", "=", "ccode", "(", "fmnfo", "->", "arg", ")", ";", "fmnfo", "->", "status", "=", "handshake", ";", "}", "*", "(", "u32_t", "*", ")", "0x4C000000", "=", "(", "u32_t", ")", "0xF00DF00D", ";", "*", "(", "u32_t", "*", ")", "0x4C000004", "=", "(", "u32_t", ")", "0xF00DBABE", ";", "*", "(", "u32_t", "*", ")", "0x4C000008", "=", "(", "u32_t", ")", "0xF00DCAFE", ";", "*", "(", "u32_t", "*", ")", "0x4C00000C", "=", "(", "u32_t", ")", "0xF00DD00D", ";", "return", ";", "}" ]

[ "Check", "manager", "magic", "and", "jump", "to", "it" ]

[]

[ { "param": "handshake", "type": "u8_t" } ]

[ "MIT" ]

[ "use", "the", "write", "primitive", "to", "add", "read32", "and", "write32", "smcs", "code", "by", "Proxima" ]

[ "static", "int", "patch_tz_peekpoke", "(", "k_root", "*", "kroot", ")", "{", "void", "(", "*", "dcl2wbivr", ")", "(", "void", "*", "va", ",", "uint32_t", "sz", ")", "=", "KFUN", "(", "\"", "\"", ",", "0x1b1d4", "|", "1", ")", ";", "if", "(", "!", "dcl2wbivr", ")", "return", "-1", ";", "unsigned", "int", "*", "shared_mem", "=", "(", "unsigned", "int", "*", ")", "(", "K_SHARED", ")", ";", "unsigned", "int", "handle", ";", "unsigned", "int", "ret", ",", "i", ";", "unsigned", "int", "index", ";", "unsigned", "int", "smc_id", "=", "0x180", ";", "unsigned", "int", "tz_shared_mem", "=", "TZ_SHARED", ";", "unsigned", "int", "tz_syscall_table", "=", "TZ_SYSCALL", ";", "unsigned", "int", "tz_target_write_address", "=", "tz_syscall_table", "+", "(", "(", "smc_id", "-", "0x100", ")", "*", "4", ")", ";", "kroot", "->", "memset", "(", "shared_mem", ",", "0", ",", "0x5000", ")", ";", "shared_mem", "[", "0x28", "/", "4", "]", "=", "TZ_PEEK", ";", "shared_mem", "[", "0x2C", "/", "4", "]", "=", "TZ_POKE", ";", "handle", "=", "tz_shared_mem", ";", "handle", ">>=", "1", ";", "index", "=", "(", "tz_target_write_address", "-", "tz_shared_mem", ")", ">>", "7", ";", "dcl2wbivr", "(", "shared_mem", ",", "0x5000", ")", ";", "__asm", "(", "\"", "\"", ")", ";", "__asm", "(", "\"", "\"", ")", ";", "ret", "=", "xsmc", "(", "handle", ",", "index", ",", "0", ",", "0", ",", "0x12F", ")", ";", "__asm", "(", "\"", "\"", ")", ";", "__asm", "(", "\"", "\"", ")", ";", "return", "ret", ";", "}" ]

[ "use", "the", "write", "primitive", "to", "add", "read32", "and", "write32", "smcs", "code", "by", "Proxima" ]

[ "// PEEK function ", "// POKE function" ]

[ { "param": "kroot", "type": "k_root" } ]