ed/refactor
1
0
Fork 0
mirror of https://github.com/Ed94/refactor.git synced 2024-12-22 15:04:45 -08:00
Code Issues Packages Projects Releases Wiki Activity

WIP - Got it somewhat working, still have issues with multiple files.

Browse Source
This commit is contained in:
Edward R. Gonzalez 2023-03-17 18:12:20 -04:00
parent 7e120ae5e9
commit 97967e56d9
15 changed files with 356 additions and 1089 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
.vscode/launch.json vendored
View File

@ -13,13 +13,34 @@
"-src=./thirdparty/zpl.h", "-src=./thirdparty/zpl.h",
"-dst=./Test/zpl.refactored.h", "-dst=./Test/zpl.refactored.h",
"-spec=./Test/zpl.h.refactor" "-spec=./Test/zpl.refactor"
], ],
"stopAtEntry": false, "stopAtEntry": false,
"cwd": "${workspaceRoot}", "cwd": "${workspaceRoot}",
"environment": [], "environment": [],
"console": "integratedTerminal" "console": "integratedTerminal"
} },
// {
// "name": "Refactor ZPL files",
// "type": "cppvsdbg",
// "request": "launch",
// "program": "${workspaceFolder}/build/refactor.exe",
// "args": [
// "-num=2",
// "-src=./thirdparty/zpl.h",
// "./thirdparty/file.h",
// "-dst=./Test/zpl.refactored.h",
// "./thirdparty/file.refactored.h",
// "-spec=./Test/zpl.refactor"
// ],
// "stopAtEntry": false,
// "cwd": "${workspaceRoot}",
// "environment": [],
// "console": "integratedTerminal"
// },
{ {
"name": "Refactor refactor.c", "name": "Refactor refactor.c",
"type": "cppvsdbg", "type": "cppvsdbg",
@ -29,7 +50,7 @@
"-source=./refactor.cpp", "-source=./refactor.cpp",
"-destination=./Test/refactor.cpp", "-destination=./Test/refactor.cpp",
"-specification=./Test/zpl.h.refactor" "-specification=./Test/zpl.refactor"
], ],
"stopAtEntry": false, "stopAtEntry": false,
"cwd": "${workspaceRoot}", "cwd": "${workspaceRoot}",

8
Readme.md
View File

@ -2,14 +2,14 @@
Refactor c/c++ files (and problably others) with ease. Refactor c/c++ files (and problably others) with ease.
Parameters : ## Parameters :
* `-num` : Used if more than one source file is provided (if used, number of destination files provided MUST MATCH). * `-num` : Used if more than one source file is provided (if used, number of destination files provided MUST MATCH).
* `-src` : Source file to refactor * `-src` : Source file to refactor
* `-dst` : Destination file after the refactor (omit to use the same as source) * `-dst` : Destination file after the refactor (omit to use the same as source)
* `-spec` : Specification containing rules to use for the refactor. * `-spec` : Specification containing rules to use for the refactor.
Syntax : ## Syntax :
* `not` Omit word or namespace. * `not` Omit word or namespace.
* `include` Preprocessor include <file> related identifiers. * `include` Preprocessor include <file> related identifiers.
@ -30,7 +30,7 @@ you may want to have automated in a script.
There are other programs more robust for doing that sort of thing but I was not able to find something this simple. There are other programs more robust for doing that sort of thing but I was not able to find something this simple.
**Note** ### Note
* Building for debug provides some nice output with context on a per-line basis. * Building for debug provides some nice output with context on a per-line basis.
* Release will only show errors for asserts (that will kill the refactor early). * Release will only show errors for asserts (that will kill the refactor early).
@ -40,6 +40,8 @@ Make sure to have the code backed up on a VCS or in some other way.
* The scripts used for building and otherwise are in the scripts directory and are all in powershell (with exception to the meson.build). Techncially there should be a powershell package available on other platorms but worst case it should be pretty easy to port these scripts to w/e shell script you'd perfer. * The scripts used for building and otherwise are in the scripts directory and are all in powershell (with exception to the meson.build). Techncially there should be a powershell package available on other platorms but worst case it should be pretty easy to port these scripts to w/e shell script you'd perfer.
TODO: TODO:
* Possibly come up with a better name. * Possibly come up with a better name.
* Test to see how much needs to be ported for other platforms (if at all) * Test to see how much needs to be ported for other platforms (if at all)
* Setup as api.
* Provide binaries in the release page for github. (debug and release builds) * Provide binaries in the release page for github. (debug and release builds)

137
Test/bloat.refactored.hpp
View File

@ -1,137 +0,0 @@
/*
BLOAT.
ZPL requires ZPL_IMPLEMENTATION whereever this library is included.
This file assumes it will be included in one compilation unit.
*/
#pragma once
#if __clang__
# pragma clang diagnostic ignored "-Wunused-const-variable"
# pragma clang diagnostic ignored "-Wswitch"
# pragma clang diagnostic ignored "-Wunused-variable"
#endif
#pragma region ZPL INCLUDE
#if __clang__
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wmissing-braces"
# pragma clang diagnostic ignored "-Wbraced-scalar-init"
#endif
// # define ZPL_HEAP_ANALYSIS
# define ZPL_NO_MATH_H
# define ZPL_DISABLE_C_DECLS
# define ZPL_WRAP_IN_NAMESPACE
# define ZPL_CUSTOM_MODULES
# define ZPL_MODULE_ESSENTIALS
# define ZPL_MODULE_CORE
# define ZPL_MODULE_TIMER
// # define ZPL_MODULE_HASHING
// # define ZPL_MODULE_REGEX
// # define ZPL_MODULE_EVENT
// # define ZPL_MODULE_DLL
# define ZPL_MODULE_OPTS
// # define ZPL_MODULE_PROCESS
// # define ZPL_MODULE_MATH
// # define ZPL_MODULE_THREADING
// # define ZPL_MODULE_JOBS
// # define ZPL_MODULE_PARSER
// extern "C" {
#include "zpl.refactored.h"
// }
#if __clang__
# pragma clang diagnostic pop
#endif
#pragma endregion ZPL INCLUDE
#define bit( Value_ ) ( 1 << Value_ )
#define bitfield_is_equal( Field_, Mask_ ) ( ( Mask_ & Field_ ) == Mask_ )
#define ct constexpr
#define gen( ... ) template< __VA_ARGS__ >
#define forceinline ZPL_ALWAYS_INLINE
#define print_nl( _) zpl_printf("\n")
#define cast( Type_, Value_ ) ( ( Type_ ), ( Value_ ) )
#define scast( Type_, Value_ ) static_cast< Type_ >( Value_ )
#define rcast( Type_, Value_ ) reinterpret_cast< Type_ >( Value_ )
#define pcast( Type_, Value_ ) ( * (Type_*)( & Value_ ) )
#define do_once() \
do \
{ \
static \
bool Done = true; \
if ( Done ) \
return; \
Done = false; \
} \
while(0) \
ct char const* Msg_Invalid_Value = "INVALID VALUE PROVIDED";
namespace Memory
{
zpl::arena Global_Arena {};
#define g_allocator arena_allocator( & Memory::Global_Arena)
void setup()
{
arena_init_from_allocator( & Global_Arena, heap(), megabytes(1) );
if ( Global_Arena.total_size == 0 )
{
zpl::assert_crash( "Failed to reserve memory for Tests:: Global_Arena" );
}
}
void cleanup()
{
arena_free( & Global_Arena);
}
}
zpl::sw log_fmt(char const *fmt, ...)
{
#if Build_Debug
zpl::sw res;
va_list va;
va_start(va, fmt);
res = zpl::printf_va(fmt, va);
va_end(va);
return res;
#else
return 0;
#endif
}
void fatal(char const *fmt, ...)
{
local_persist thread_local
char buf[ZPL_PRINTF_MAXLEN] = { 0 };
va_list va;
#if Build_Debug
va_start(va, fmt);
zpl::snprintf_va(buf, ZPL_PRINTF_MAXLEN, fmt, va);
va_end(va);
zpl::assert_crash(buf);
#else
va_start(va, fmt);
zpl::printf_err_va( fmt, va);
va_end(va);
zpl::exit(1);
#endif
}

0
Test/project.refactor Normal file
View File

770
Test/refactor.refactored.cpp
View File

@ -1,770 +0,0 @@
#define ZPL_IMPLEMENTATION
#include "bloat.refactored.hpp"
namespace File
{
using namespace zpl;
string Source = nullptr;
string Destination = nullptr;
file_contents Content {};
arena Buffer;
void cleanup()
{
arena_free( & Buffer );
}
void read()
{
file file_src = {};
Content.allocator = g_allocator;
file_error error_src = file_open( & file_src, Source );
if ( error_src == ZPL_FILE_ERROR_NONE )
{
sw fsize = zpl_cast(sw) file_size( & file_src);
if ( fsize > 0 )
{
arena_init_from_allocator( & Buffer, heap(), (fsize + fsize % 64) * 4 );
Content.data = alloc( arena_allocator( & Buffer), fsize);
Content.size = fsize;
file_read_at ( & file_src, Content.data, Content.size, 0);
}
file_close( & file_src);
}
if ( Content.data == nullptr )
{
fatal( "Unable to open source file: %s\n", Source );
}
}
void write(string refactored)
{
if ( refactored == nullptr)
return;
file file_dest {};
file_error error = file_create( & file_dest, Destination );
if ( error != ZPL_FILE_ERROR_NONE )
{
fatal( "Unable to open destination file: %s\n", Destination );
}
file_write( & file_dest, refactored, string_length(refactored) );
}
}
namespace Spec
{
using namespace zpl;
string File;
enum Tok
{
Not,
Namespace,
Word,
Num_Tok
};
ct
char const* str_tok( Tok tok )
{
ct
char const* tok_to_str[ Tok::Num_Tok ] =
{
"not",
"namespace",
"word",
};
return tok_to_str[ tok ];
}
ct
char strlen_tok( Tok tok )
{
ct
const u8 tok_to_len[ Tok::Num_Tok ] =
{
3,
9,
4,
};
return tok_to_len[ tok ];
}
forceinline
bool is_tok( Tok tok, string str, u32 length )
{
char const* tok_str = str_tok(tok);
const u8 tok_len = strlen_tok(tok);
if ( tok_len != length)
return false;
s32 result = str_compare( tok_str, str, tok_len );
return result == 0;
}
struct Entry
{
string Sig = nullptr; // Signature
string Sub = nullptr; // Substitute
};
arena Buffer {};
zpl_array(Entry) Word_Ignores;
zpl_array(Entry) Namespace_Ignores;
zpl_array(Entry) Words;
zpl_array(Entry) Namespaces;
u32 Sig_Smallest = kilobytes(1);
forceinline
void find_next_token( string& token, char*& line, u32& length )
{
string_clear( token );
length = 0;
while ( char_is_alphanumeric( line[length] ) || line[length] == '_' )
{
length++;
}
if ( length == 0 )
{
fatal("Failed to find valid initial token");
}
token = string_append_length( token, line, length );
line += length;
}
void process()
{
char* content;
zpl_array(char*) lines;
// Get the contents of the file.
{
file file {};
file_error error = file_open( & file, File);
if ( error != ZPL_FILE_ERROR_NONE )
{
fatal("Could not open the specification file: %s", File);
}
sw fsize = scast( sw, file_size( & file ) );
if ( fsize <= 0 )
{
fatal("No content in specificaiton to process");
}
arena_init_from_allocator( & Buffer, heap(), (fsize + fsize % 64) * 10 + kilobytes(1) );
char* content = rcast( char*, alloc( arena_allocator( & Buffer), fsize + 1) );
file_read( & file, content, fsize);
content[fsize] = 0;
lines = str_split_lines( arena_allocator( & Buffer ), content, false );
file_close( & file );
}
sw left = array_count( lines );
if ( left == 0 )
{
fatal("Spec::process: lines array imporoperly setup");
}
// Skip the first line as its the version number and we only support __VERSION 1.
left--;
lines++;
array_init( Word_Ignores, arena_allocator( & Buffer));
array_init( Namespace_Ignores, arena_allocator( & Buffer));
array_init( Words, arena_allocator( & Buffer));
array_init( Namespaces, arena_allocator( & Buffer));
// Limiting the maximum output of a token to 1 KB
string token = string_make_reserve( arena_allocator( & Buffer), kilobytes(1));
while ( left-- )
{
char* line = * lines;
// Ignore line if its a comment
if ( line[0] == '/' && line[1] == '/')
{
lines++;
continue;
}
// Remove indent
{
while ( char_is_space( line[0] ) )
line++;
if ( line[0] == '\0' )
{
lines++;
continue;
}
}
u32 length = 0;
// Find a valid token
find_next_token( token, line, length );
Tok type = Tok::Num_Tok;
bool ignore = false;
Entry entry {};
// Will be reguarded as an ignore.
if ( is_tok( Tok::Not, token, length ))
{
ignore = true;
while ( char_is_space( line[0] ) )
line++;
if ( line[0] == '\0' )
{
lines++;
continue;
}
// Find the category token
find_next_token( token, line, length );
}
if ( is_tok( Tok::Namespace, token, length ) )
{
type = Tok::Namespace;
}
else if ( is_tok( Tok::Word, token, length ) )
{
type = Tok::Word;
}
// Parse line.
{
// Find first argument
{
while ( char_is_space( line[0] ) )
line++;
if ( line[0] == '\0' )
{
lines++;
continue;
}
}
find_next_token( token, line, length );
// First argument is signature.
entry.Sig = string_make_length( g_allocator, token, length );
if ( length < Sig_Smallest )
Sig_Smallest = length;
if ( line[0] == '\0' || ignore )
{
switch ( type )
{
case Tok::Namespace:
if ( ignore)
array_append( Namespace_Ignores, entry );
else
array_append( Namespaces, entry );
break;
case Tok::Word:
if ( ignore)
{
array_append( Word_Ignores, entry );
u32 test = array_count( Word_Ignores );
}
else
array_append( Words, entry );
break;
}
lines++;
continue;
}
// Look for second argument indicator
{
bool bSkip = false;
while ( line[0] != ',' )
{
if ( line[0] == '\0' )
{
switch ( type )
{
case Tok::Namespace:
array_append( Namespaces, entry );
break;
case Tok::Word:
array_append( Words, entry );
break;
}
bSkip = true;
break;
}
line++;
}
if ( bSkip )
{
lines++;
continue;
}
}
// Eat the argument delimiter.
line++;
// Remove spacing
{
bool bSkip = true;
while ( char_is_space( line[0] ) )
line++;
if ( line[0] == '\0' )
{
switch ( type )
{
case Tok::Namespace:
array_append( Namespaces, entry );
break;
case Tok::Word:
array_append( Words, entry );
break;
}
lines++;
continue;
}
}
find_next_token( token, line, length );
// Second argument is substitute.
entry.Sub = string_make_length( g_allocator, token, length );
switch ( type )
{
case Tok::Namespace:
array_append( Namespaces, entry );
lines++;
continue;
case Tok::Word:
array_append( Words, entry );
lines++;
continue;
}
}
log_fmt("Specification Line: %d is missing valid keyword", array_count(lines) - left);
lines++;
}
}
void cleanup()
{
arena_free( & Buffer );
}
}
using namespace zpl;
struct Token
{
u32 Start;
u32 End;
string Sig;
string Sub;
};
void refactor()
{
sw buffer_size = File::Content.size;
zpl_array(Token) tokens;
array_init( tokens, g_allocator);
char* content = rcast( char*, File::Content.data );
string current = string_make( g_allocator, "");
string preview = string_make( g_allocator, "");
sw left = File::Content.size;
sw line = 0;
while ( left )
{
if ( content[0] == '\n' )
{
line++;
}
// Word Ignores
{
Spec::Entry* ignore = Spec::Word_Ignores;
sw ignores_left = array_count( Spec::Word_Ignores);
do
{
if ( ignore->Sig[0] != content[0] )
{
continue;
}
string_clear( current );
u32 sig_length = string_length( ignore->Sig );
current = string_append_length( current, content, sig_length );
if ( string_are_equal( ignore->Sig, current ) )
{
char before = content[-1];
char after = content[sig_length];
if ( char_is_alphanumeric( before ) || before == '_'
|| char_is_alphanumeric( after ) || after == '_' )
{
continue;
}
log_fmt("\nIgnored %-81s line %d", current, line );
content += sig_length;
left -= sig_length;
goto Skip;
}
}
while ( ignore++, --ignores_left );
}
// Namespace Ignores
{
Spec::Entry* ignore = Spec::Namespace_Ignores;
sw ignores_left = array_count( Spec::Namespace_Ignores);
do
{
if ( ignore->Sig[0] != content[0] )
{
continue;
}
string_clear( current );
u32 sig_length = string_length( ignore->Sig );
current = string_append_length( current, content, sig_length );
if ( string_are_equal( ignore->Sig, current ) )
{
u32 length = sig_length;
char* ns_content = content + sig_length;
while ( char_is_alphanumeric( ns_content[0] ) || ns_content[0] == '_' )
{
length++;
ns_content++;
}
string_clear( preview );
preview = string_append_length( preview, content, length );
log_fmt("\nIgnored %-40s %-40s line %d", preview, ignore->Sig, line);
content += length;
left -= length;
goto Skip;
}
}
while ( ignore++, --ignores_left );
}
// Words to match
{
Spec::Entry* word = Spec::Words;
sw words_left = array_count ( Spec::Words);
do
{
if ( word->Sig[0] != content[0] )
{
continue;
}
string_clear( current );
sw sig_length = string_length( word->Sig);
current = string_append_length( current, content, sig_length );
if ( string_are_equal( word->Sig, current ) )
{
char before = content[-1];
char after = content[sig_length];
if ( char_is_alphanumeric( before ) || before == '_'
|| char_is_alphanumeric( after ) || after == '_' )
{
continue;
}
Token entry {};
entry.Start = File::Content.size - left;
entry.End = entry.Start + sig_length;
entry.Sig = word->Sig;
if ( word->Sub != nullptr )
{
entry.Sub = word->Sub;
buffer_size += string_length( entry.Sub) - sig_length;
}
array_append( tokens, entry );
log_fmt("\nFound %-81s line %d", current, line);
content += sig_length;
left -= sig_length;
goto Skip;
}
}
while ( word++, --words_left );
}
// Namespaces to match
{
Spec::Entry* nspace = Spec::Namespaces;
sw nspaces_left = array_count( Spec::Namespaces);
do
{
if ( nspace->Sig[0] != content[0] )
{
continue;
}
string_clear( current );
u32 sig_length = string_length( nspace->Sig );
current = string_append_length( current, content, sig_length );
if ( string_are_equal( nspace->Sig, current ) )
{
u32 length = sig_length;
char* ns_content = content + sig_length;
while ( char_is_alphanumeric( ns_content[0] ) || ns_content[0] == '_' )
{
length++;
ns_content++;
}
Token entry {};
entry.Start = File::Content.size - left;
entry.End = entry.Start + length;
entry.Sig = nspace->Sig;
buffer_size += sig_length;
if ( nspace->Sub != nullptr )
{
entry.Sub = nspace->Sub;
buffer_size += string_length( entry.Sub ) - length;
}
array_append( tokens, entry );
string_clear( preview );
preview = string_append_length( preview, content, length);
log_fmt("\nFound %-40s %-40s line %d", preview, nspace->Sig, line);
content += length;
left -= length;
}
}
while ( nspace++, --nspaces_left );
}
content++;
left--;
Skip:
continue;
}
left = array_count( tokens);
content = rcast( char*, File::Content.data);
// Generate the refactored file content.
arena buffer;
string refactored = nullptr;
{
Token* entry = tokens;
if ( entry == nullptr)
return;
arena_init_from_allocator( & buffer, heap(), buffer_size * 2 );
string
new_string = string_make_reserve( arena_allocator( & buffer), kilobytes(1) );
refactored = string_make_reserve( arena_allocator( & buffer), buffer_size );
sw previous_end = 0;
while ( left-- )
{
sw segment_length = entry->Start - previous_end;
sw sig_length = string_length( entry->Sig );
// Append between tokens
refactored = string_append_length( refactored, content, segment_length );
content += segment_length + sig_length;
segment_length = entry->End - entry->Start - sig_length;
// Append token
if ( entry->Sub )
refactored = string_append( refactored, entry->Sub );
refactored = string_append_length( refactored, content, segment_length );
content += segment_length;
previous_end = entry->End;
entry++;
}
entry--;
if ( entry->End < File::Content.size )
{
refactored = string_append_length( refactored, content, File::Content.size - entry->End );
}
}
// Write refactored content to destination.
File::write( refactored );
arena_free( & buffer );
}
inline
void parse_options( int num, char** arguments )
{
opts opts;
opts_init( & opts, g_allocator, "refactor");
opts_add( & opts, "source" , "src" , "File to refactor" , ZPL_OPTS_STRING);
opts_add( & opts, "destination" , "dst" , "File post refactor" , ZPL_OPTS_STRING);
opts_add( & opts, "specification", "spec", "Specification for refactoring", ZPL_OPTS_STRING);
if (opts_compile( & opts, num, arguments))
{
if ( opts_has_arg( & opts, "src" ) )
{
string opt = opts_string( & opts, "src", "INVALID PATH" );
File::Source = string_make( g_allocator, "" );
File::Source = string_append( File::Source, opt );
}
else
{
fatal( "-source not provided\n" );
}
if ( opts_has_arg( & opts, "dst" ) )
{
string opt = opts_string( & opts, "dst", "INVALID PATH" );
File::Destination = string_make( g_allocator, "" );
File::Destination = string_append( File::Destination, opt );
}
else if ( File::Source )
{
File::Destination = string_make( g_allocator, "" );
File::Destination = string_append( File::Destination, File::Source );
}
if ( opts_has_arg( & opts, "spec" ) )
{
string opt = opts_string( & opts, "spec", "INVALID PATH" );
Spec::File = string_make( g_allocator, "" );
Spec::File = string_append( Spec::File, opt );
}
}
else
{
fatal( "Failed to parse arguments\n" );
}
opts_free( & opts);
}
int main( int num, char** arguments)
{
Memory::setup();
parse_options( num, arguments );
if ( Spec::File )
Spec::process();
File::read();
refactor();
Spec:: cleanup();
File:: cleanup();
Memory::cleanup();
}

40
Test/zpl.refactor
View File

@ -1,14 +1,17 @@
__VERSION 1 __VERSION 1
// not : Ignore // not : Ignore
// word : Alphanumeric or underscore // include : #includes
// regex : Unavailable in __VERSION 1. // word : Alphanumeric or underscore
// namespace : Prefix search and replace (c-namspaces).
// regex : Unavailable in __VERSION 1.
// Precedence (highest to lowest): // Precedence (highest to lowest):
// word, namespace, regex // word, namespace, regex
// Header files // Header files
not word zpl_hedley not include zpl_hedley
//not word zpl_hedley
// Removes the namespace. // Removes the namespace.
namespace zpl_ namespace zpl_
@ -16,30 +19,32 @@ namespace zpl_
// Don't expose internals // Don't expose internals
not namespace zpl__ not namespace zpl__
not word ZPL_IMPLEMENTATION // Macro exposure
//namespace ZPL_
//not word ZPL_IMPLEMENTATION
word cast, zpl_cast word cast, zpl_cast
word zpl_strncmp, str_compare word zpl_strncmp, str_compare
word zpl_strcmp, str_compare word zpl_strcmp, str_compare
// Undesired typedefs // Undesired typedefs
word zpl_i8, s8 word zpl_i8, s8
word zpl_i16, s16 word zpl_i16, s16
word zpl_i32, s32 word zpl_i32, s32
word zpl_i64, s64 word zpl_i64, s64
word zpl_u8, u8 word zpl_u8, u8
word zpl_u16, u16 word zpl_u16, u16
word zpl_u32, u32 word zpl_u32, u32
word zpl_u64, u64 word zpl_u64, u64
word zpl_intptr, sptr word zpl_intptr, sptr
word zpl_uintptr, uptr word zpl_uintptr, uptr
word zpl_usize, uw word zpl_usize, uw
word zpl_isize, sw word zpl_isize, sw
// Undesired exposures. // Undesired exposures.
//not word zpl_allocator //not word zpl_allocator
//not word zpl_arena //not word zpl_arena
not word zpl_array //not word zpl_array
//not word zpl_file //not word zpl_file
//not word zpl_list //not word zpl_list
//not word zpl_pool //not word zpl_pool
@ -47,6 +52,7 @@ not word zpl_array
// Conflicts with refactor // Conflicts with refactor
word arena, a_arena word arena, a_arena
word array, a_array
word alloc, a_allocator word alloc, a_allocator
word file, a_file word file, a_file
word file_size, fsize word file_size, fsize

132
project/Bloat.cpp
View File

@ -1,5 +1,5 @@
#define BLOAT_IMPL #define BLOAT_IMPL
#include "bloat.hpp" #include "Bloat.hpp"
@ -35,3 +35,133 @@ namespace Memory
zpl_arena_free( & Global_Arena); zpl_arena_free( & Global_Arena);
} }
} }
bool opts_custom_add(zpl_opts* opts, zpl_opts_entry *t, char* b)
{
if (t->type != ZPL_OPTS_STRING)
{
return false;
}
t->text = zpl_string_append_length(t->text, " ", 1);
t->text = zpl_string_appendc( t->text, b );
return true;
}
b32 opts_custom_compile(zpl_opts *opts, int argc, char **argv)
{
zpl_b32 had_errors = false;
for (int i = 1; i < argc; ++i)
{
char* arg = argv[i];
if (*arg)
{
arg = cast(char*)zpl_str_trim(arg, false);
if (*arg == '-')
{
zpl_opts_entry* entry = 0;
zpl_b32 checkln = false;
if ( *(arg + 1) == '-')
{
checkln = true;
++arg;
}
char *b = arg + 1, *e = b;
while (zpl_char_is_alphanumeric(*e) || *e == '-' || *e == '_') {
++e;
}
entry = zpl__opts_find(opts, b, (e - b), checkln);
if (entry)
{
char *ob = b;
b = e;
/**/
if (*e == '=')
{
if (entry->type == ZPL_OPTS_FLAG)
{
*e = '\0';
zpl__opts_push_error(opts, ob, ZPL_OPTS_ERR_EXTRA_VALUE);
had_errors = true;
continue;
}
b = e = e + 1;
}
else if (*e == '\0')
{
char *sp = argv[i+1];
if (sp && *sp != '-' && (zpl_array_count(opts->positioned) < 1 || entry->type != ZPL_OPTS_FLAG))
{
if (entry->type == ZPL_OPTS_FLAG)
{
zpl__opts_push_error(opts, b, ZPL_OPTS_ERR_EXTRA_VALUE);
had_errors = true;
continue;
}
arg = sp;
b = e = sp;
++i;
}
else
{
if (entry->type != ZPL_OPTS_FLAG)
{
zpl__opts_push_error(opts, ob, ZPL_OPTS_ERR_MISSING_VALUE);
had_errors = true;
continue;
}
entry->met = true;
continue;
}
}
e = cast(char *)zpl_str_control_skip(e, '\0');
zpl__opts_set_value(opts, entry, b);
if ( (i + 1) < argc )
{
for ( b = argv[i + 1]; i < argc && b[0] != '-'; i++, b = argv[i + 1] )
{
opts_custom_add(opts, entry, b );
}
}
}
else
{
zpl__opts_push_error(opts, b, ZPL_OPTS_ERR_OPTION);
had_errors = true;
}
}
else if (zpl_array_count(opts->positioned))
{
zpl_opts_entry *l = zpl_array_back(opts->positioned);
zpl_array_pop(opts->positioned);
zpl__opts_set_value(opts, l, arg);
}
else
{
zpl__opts_push_error(opts, arg, ZPL_OPTS_ERR_VALUE);
had_errors = true;
}
}
}
return !had_errors;
}

37
project/IO.cpp
View File

@ -13,23 +13,12 @@ namespace IO
// Current source and destination index. // Current source and destination index.
// Used to keep track of which file get_next_source or write refer to. // Used to keep track of which file get_next_source or write refer to.
uw Current = 0; sw Current = -1;
char* Current_Content = nullptr; char* Current_Content = nullptr;
uw Current_Size = 0; uw Current_Size = 0;
uw Largest_Src_Size = 0; uw Largest_Src_Size = 0;
/*
Will persist throughout loading different file content.
Should hold a bit more than the largest source file's content,
As an array of lines.
*/
zpl_arena MemPerist; zpl_arena MemPerist;
/*
Temporary memory held while procesisng files to get their content.
zpl_files are stored here
*/
// zpl_arena MemTransient;
} }
using namespace StaticData; using namespace StaticData;
@ -48,7 +37,7 @@ namespace IO
if ( error != ZPL_FILE_ERROR_NONE ) if ( error != ZPL_FILE_ERROR_NONE )
{ {
fatal("Could not open source file: %s", *path ); fatal("IO::Prepare - Could not open source file: %s", *path );
} }
const sw fsize = zpl_file_size( & src ); const sw fsize = zpl_file_size( & src );
@ -60,18 +49,16 @@ namespace IO
zpl_file_close( & src ); zpl_file_close( & src );
} }
while ( --left ); while ( left--, left > 1 );
uw persist_size = ZPL_ARRAY_GROW_FORMULA( Largest_Src_Size ); uw persist_size = ZPL_ARRAY_GROW_FORMULA( Largest_Src_Size );
zpl_arena_init_from_allocator( & MemPerist, zpl_heap(), persist_size ); zpl_arena_init_from_allocator( & MemPerist, zpl_heap(), persist_size );
// zpl_arena_init_from_allocator( & MemTransient, zpl_heap(), Largest_Src_Size );
} }
void cleanup() void cleanup()
{ {
zpl_arena_free( & MemPerist ); zpl_arena_free( & MemPerist );
// zpl_arena_free( & MemTransient );
} }
Array_Line get_specification() Array_Line get_specification()
@ -102,25 +89,24 @@ namespace IO
return lines; return lines;
} }
Array_Line get_next_source() char* get_next_source()
{ {
// zpl_memset( MemTransient.physical_start, 0, MemTransient.total_allocated);
// MemTransient.total_allocated = 0;
// MemTransient.temp_count = 0;
zpl_memset( MemPerist.physical_start, 0, MemPerist.total_allocated); zpl_memset( MemPerist.physical_start, 0, MemPerist.total_allocated);
MemPerist.total_allocated = 0; MemPerist.total_allocated = 0;
MemPerist.temp_count = 0; MemPerist.temp_count = 0;
Current++;
zpl_file file {}; zpl_file file {};
zpl_file_error error = zpl_file_open( & file, Specification); zpl_file_error error = zpl_file_open( & file, Sources[Current]);
if ( error != ZPL_FILE_ERROR_NONE ) if ( error != ZPL_FILE_ERROR_NONE )
{ {
fatal("Could not open the source file: %s", Sources[Current]); fatal("IO::get_next_source - Could not open the source file: %s", Sources[Current]);
} }
Current_Size = scast( sw, zpl_file_size( & file ) ); auto size = zpl_file_size( & file );
Current_Size = scast( sw, size );
if ( Current_Size <= 0 ) if ( Current_Size <= 0 )
return nullptr; return nullptr;
@ -133,8 +119,7 @@ namespace IO
Current_Content[Current_Size] = 0; Current_Content[Current_Size] = 0;
Current_Size++; Current_Size++;
Array_Line lines = zpl_str_split_lines( zpl_arena_allocator( & MemPerist), Current_Content, ' ' ); return Current_Content;
return lines;
} }
void write( zpl_string refacotred ) void write( zpl_string refacotred )

4
project/IO.hpp
View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include "bloat.hpp" #include "Bloat.hpp"
namespace IO namespace IO
@ -18,7 +18,7 @@ namespace IO
Array_Line get_specification(); Array_Line get_specification();
// Provides the content of the next source, broken up as a series of lines. // Provides the content of the next source, broken up as a series of lines.
Array_Line get_next_source(); char* get_next_source();
// Writes the refactored content ot the current corresponding destination. // Writes the refactored content ot the current corresponding destination.
void write( zpl_string refactored ); void write( zpl_string refactored );

2
project/Spec.cpp
View File

@ -96,8 +96,6 @@ namespace Spec
left--; left--;
lines++; lines++;
char token[ Token_Max_Length ];
do do
{ {
char* line = * lines; char* line = * lines;

6
project/bloat.hpp
View File

@ -5,7 +5,7 @@
#pragma once #pragma once
#ifdef BLOAT_IMPL #ifdef BLOAT_IMPL
# define ZPL_IMPLEMEntATION # define ZPL_IMPLEMENTATION
#endif #endif
#if __clang__ #if __clang__
@ -70,6 +70,7 @@ do \
while(0) \ while(0) \
using b32 = zpl_b32;
using s8 = zpl_i8; using s8 = zpl_i8;
using s32 = zpl_i32; using s32 = zpl_i32;
using s64 = zpl_i64; using s64 = zpl_i64;
@ -97,6 +98,9 @@ namespace Memory
void cleanup(); void cleanup();
} }
// Had to be made to support multiple sub-arguments per "opt" argument.
b32 opts_custom_compile(zpl_opts *opts, int argc, char **argv);
inline inline
sw log_fmt(char const *fmt, ...) sw log_fmt(char const *fmt, ...)
{ {

217
project/refactor.cpp
View File

@ -1,5 +1,4 @@
#define BLOAT_IMPL #include "Bloat.cpp"
#include "bloat.hpp"
#include "IO.cpp" #include "IO.cpp"
#include "Spec.cpp" #include "Spec.cpp"
@ -16,7 +15,7 @@ void parse_options( int num, char** arguments )
zpl_opts_add( & opts, "dst" , "dst" , "File/s post refactor" , ZPL_OPTS_STRING); zpl_opts_add( & opts, "dst" , "dst" , "File/s post refactor" , ZPL_OPTS_STRING);
zpl_opts_add( & opts, "spec", "spec", "Specification for refactoring", ZPL_OPTS_STRING); zpl_opts_add( & opts, "spec", "spec", "Specification for refactoring", ZPL_OPTS_STRING);
if (zpl_opts_compile( & opts, num, arguments)) if (opts_custom_compile( & opts, num, arguments))
{ {
sw num = 0; sw num = 0;
@ -36,15 +35,21 @@ void parse_options( int num, char** arguments )
else else
{ {
num = 1; num = 1;
zpl_array_init_reserve( IO::Sources, g_allocator, 1 );
zpl_array_init_reserve( IO::Destinations, g_allocator, 1 );
} }
zpl_printf("NUM IS: %d", num);
if ( zpl_opts_has_arg( & opts, "src" ) ) if ( zpl_opts_has_arg( & opts, "src" ) )
{ {
zpl_string opt = zpl_opts_string( & opts, "src", "INVALID SRC ARGUMENT" ); zpl_string opt = zpl_opts_string( & opts, "src", "INVALID SRC ARGUMENT" );
if ( num == 1 ) if ( num == 1 )
{ {
IO::Sources[0] = zpl_string_make_length( g_allocator, opt, zpl_string_length( opt) ); zpl_string path = zpl_string_make_length( g_allocator, opt, zpl_string_length( opt ));
zpl_array_append( IO::Sources, path );
} }
else else
{ {
@ -60,9 +65,10 @@ void parse_options( int num, char** arguments )
{ {
path[length] = *opt; path[length] = *opt;
} }
while ( length++, opt++, *opt != ' ' ); while ( length++, opt++, *opt != ' ' && *opt != '\0' );
IO::Sources[num - left] = zpl_string_make_length( g_allocator, path, length ); zpl_string path_string = zpl_string_make_length( g_allocator, path, length );
zpl_array_append( IO::Sources, path_string );
opt++; opt++;
} }
@ -71,7 +77,7 @@ void parse_options( int num, char** arguments )
} }
else else
{ {
fatal( "-source not provided\n" ); fatal( "-src not provided\n" );
} }
if ( zpl_opts_has_arg( & opts, "dst" ) ) if ( zpl_opts_has_arg( & opts, "dst" ) )
@ -80,7 +86,8 @@ void parse_options( int num, char** arguments )
if ( num == 1 ) if ( num == 1 )
{ {
IO::Destinations[0] = zpl_string_make_length( g_allocator, opt, zpl_string_length( opt) ); zpl_string path = zpl_string_make_length( g_allocator, opt, zpl_string_length( opt) );
zpl_array_append( IO::Destinations, path );
} }
else else
{ {
@ -96,15 +103,30 @@ void parse_options( int num, char** arguments )
{ {
path[length] = *opt; path[length] = *opt;
} }
while ( length++, opt++, *opt != ' ' ); while ( length++, opt++, *opt != ' ' && *opt != '\0' );
IO::Destinations[num - left] = zpl_string_make_length( g_allocator, path, length ); zpl_string path_string = zpl_string_make_length( g_allocator, path, length );
zpl_array_append( IO::Destinations, path_string );
opt++; opt++;
} }
while ( --left ); while ( --left );
if ( zpl_array_count(IO::Destinations) != zpl_array_count( IO::Sources ) )
{
fatal("-dst count must match -src count");
}
} }
} }
else
{
uw left = num;
do
{
zpl_array_append( IO::Destinations, IO::Sources[num - left] );
}
while ( --left );
}
if ( zpl_opts_has_arg( & opts, "spec" ) ) if ( zpl_opts_has_arg( & opts, "spec" ) )
{ {
@ -113,9 +135,18 @@ void parse_options( int num, char** arguments )
IO::Specification = zpl_string_make( g_allocator, "" ); IO::Specification = zpl_string_make( g_allocator, "" );
IO::Specification = zpl_string_append( IO::Specification, opt ); IO::Specification = zpl_string_append( IO::Specification, opt );
} }
else
{
fatal( "-spec not provided\n" );
}
} }
else else
{ {
zpl_printf("\nArguments: ");
for ( int index = 0; index < num; index++)
{
zpl_printf("\nArg[%d]: %s", index, arguments[index]);
}
fatal( "Failed to parse arguments\n" ); fatal( "Failed to parse arguments\n" );
} }
@ -127,7 +158,7 @@ zpl_arena Refactor_Buffer;
void refactor() void refactor()
{ {
ct char const* include_sig = "#include \""; ct static char const* include_sig = "#include \"";
struct Token struct Token
{ {
@ -157,61 +188,62 @@ void refactor()
} }
// Prepare data and trackers. // Prepare data and trackers.
Array_Line src = IO::get_next_source(); char const* src = IO::get_next_source();
Array_Line lines = src;
if ( src == nullptr ) if ( src == nullptr )
return; return;
const sw num_lines = zpl_array_count( lines); log_fmt("\n\nRefactoring: %s", IO::Sources[IO::Current]);
sw buffer_size = IO::Current_Size; sw buffer_size = IO::Current_Size;
sw left = num_lines; sw left = buffer_size;
Line line = *lines; uw col = 0;
uw pos = 0; uw line = 0;
#define pos (IO::Current_Size - left)
#define move_forward( Amount_ ) \
left -= Amount_; \
col += Amount_; \
src += Amount_ \
do do
{ {
Continue_Line:
// Includes to ignore // Includes to ignore
{ {
Spec::Entry* ignore = Spec::Ignore_Words; Spec::Entry* ignore = Spec::Ignore_Includes;
sw ignores_left = zpl_array_count( Spec::Ignore_Words); sw ignores_left = zpl_array_count( Spec::Ignore_Includes);
do for ( ; ignores_left; ignores_left--, ignore++ )
{ {
if ( include_sig[0] != line[0] ) if ( include_sig[0] != src[0] )
continue; continue;
u32 sig_length = zpl_string_length( ignore->Sig ); u32 sig_length = zpl_string_length( ignore->Sig );
current = zpl_string_set( current, include_sig ); current = zpl_string_set( current, include_sig );
current = zpl_string_append_length( current, line, sig_length ); current = zpl_string_append_length( current, src, sig_length );
current = zpl_string_append_length( current, "\"", 2 ); current = zpl_string_append_length( current, "\"", 1 );
// Formats current into: #include "<ignore->Sig>" // Formats current into: #include "<ignore->Sig>"
if ( zpl_string_are_equal( ignore->Sig, current ) ) if ( zpl_string_are_equal( ignore->Sig, current ) )
{ {
log_fmt("\nIgnored %-81s line %d", current, num_lines - left ); log_fmt("\nIgnored %-81s line %d, col %d", current, line, col );
const sw length = zpl_string_length( current ); const sw length = zpl_string_length( current );
line += length; move_forward( length );
pos += length;
// Force end of line. // Force end of line.
while ( line != '\0' ) while ( src[0] != '\n' )
{ {
line++; move_forward( 1 );
pos++;
} }
goto Skip; goto Skip;
} }
} }
while ( ignore++, --ignores_left );
} }
// Word Ignores // Word Ignores
@ -219,20 +251,20 @@ void refactor()
Spec::Entry* ignore = Spec::Ignore_Words; Spec::Entry* ignore = Spec::Ignore_Words;
sw ignores_left = zpl_array_count( Spec::Ignore_Words); sw ignores_left = zpl_array_count( Spec::Ignore_Words);
do for ( ; ignores_left; ignores_left--, ignore++ )
{ {
if ( ignore->Sig[0] != line[0] ) if ( ignore->Sig[0] != src[0] )
continue; continue;
zpl_string_clear( current ); zpl_string_clear( current );
u32 sig_length = zpl_string_length( ignore->Sig ); u32 sig_length = zpl_string_length( ignore->Sig );
current = zpl_string_append_length( current, line, sig_length ); current = zpl_string_append_length( current, src, sig_length );
if ( zpl_string_are_equal( ignore->Sig, current ) ) if ( zpl_string_are_equal( ignore->Sig, current ) )
{ {
char before = line[-1]; char before = src[-1];
char after = line[sig_length]; char after = src[sig_length];
if ( zpl_char_is_alphanumeric( before ) || before == '_' if ( zpl_char_is_alphanumeric( before ) || before == '_'
|| zpl_char_is_alphanumeric( after ) || after == '_' ) || zpl_char_is_alphanumeric( after ) || after == '_' )
@ -240,14 +272,12 @@ void refactor()
continue; continue;
} }
log_fmt("\nIgnored %-81s line %d", current, num_lines - left ); log_fmt("\nIgnored %-81s line %d, col %d", current, line, col );
line += sig_length; move_forward( sig_length );
pos += sig_length;
goto Skip; goto Skip;
} }
} }
while ( ignore++, --ignores_left );
} }
// Namespace Ignores // Namespace Ignores
@ -255,20 +285,23 @@ void refactor()
Spec::Entry* ignore = Spec::Ignore_Namespaces; Spec::Entry* ignore = Spec::Ignore_Namespaces;
sw ignores_left = zpl_array_count( Spec::Ignore_Namespaces); sw ignores_left = zpl_array_count( Spec::Ignore_Namespaces);
do for ( ; ignores_left; ignores_left--, ignore++ )
{ {
if ( ignore->Sig[0] != line[0] ) if ( ignore->Sig[0] != src[0] )
{
ignore++;
continue; continue;
}
zpl_string_clear( current ); zpl_string_clear( current );
u32 sig_length = zpl_string_length( ignore->Sig ); u32 sig_length = zpl_string_length( ignore->Sig );
current = zpl_string_append_length( current, line, sig_length ); current = zpl_string_append_length( current, src, sig_length );
if ( zpl_string_are_equal( ignore->Sig, current ) ) if ( zpl_string_are_equal( ignore->Sig, current ) )
{ {
u32 length = sig_length; u32 length = sig_length;
char* ns_content = line + sig_length; char const* ns_content = src + sig_length;
while ( zpl_char_is_alphanumeric( ns_content[0] ) || ns_content[0] == '_' ) while ( zpl_char_is_alphanumeric( ns_content[0] ) || ns_content[0] == '_' )
{ {
@ -278,16 +311,14 @@ void refactor()
#if Build_Debug #if Build_Debug
zpl_string_clear( preview ); zpl_string_clear( preview );
preview = zpl_string_append_length( preview, line, length ); preview = zpl_string_append_length( preview, src, length );
log_fmt("\nIgnored %-40s %-40s line %d", preview, ignore->Sig, - left); log_fmt("\nIgnored %-40s %-40s line %d, column %d", preview, ignore->Sig, line, col );
#endif #endif
line += length; move_forward( length );
pos += length;
goto Skip; goto Skip;
} }
} }
while ( ignore++, --ignores_left );
} }
// Includes to match // Includes to match
@ -296,16 +327,16 @@ void refactor()
sw includes_left = zpl_array_count ( Spec::Includes); sw includes_left = zpl_array_count ( Spec::Includes);
do for ( ; includes_left; includes_left--, include++ )
{ {
if ( include_sig[0] != line[0] ) if ( include_sig[0] != src[0] )
continue; continue;
u32 sig_length = zpl_string_length( include->Sig ); u32 sig_length = zpl_string_length( include->Sig );
current = zpl_string_set( current, include_sig ); current = zpl_string_set( current, include_sig );
current = zpl_string_append_length( current, line, sig_length ); current = zpl_string_append_length( current, src, sig_length );
current = zpl_string_append_length( current, "\"", 2 ); current = zpl_string_append_length( current, "\"", 1 );
// Formats current into: #include "<ignore->Sig>" // Formats current into: #include "<ignore->Sig>"
if ( zpl_string_are_equal( include->Sig, current ) ) if ( zpl_string_are_equal( include->Sig, current ) )
@ -326,22 +357,19 @@ void refactor()
zpl_array_append( tokens, entry ); zpl_array_append( tokens, entry );
log_fmt("\nFound %-81s line %d", current, num_lines - left); log_fmt("\nFound %-81s line %d, column %d", current, line, col );
line += length; move_forward( length );
pos += length;
// Force end of line. // Force end of line.
while ( line != '\0' ) while ( src[0] != '\0' )
{ {
line++; move_forward( 1 );
pos++;
} }
goto Skip; goto Skip;
} }
} }
while ( include++, --includes_left );
} }
// Words to match // Words to match
@ -349,20 +377,20 @@ void refactor()
Spec::Entry* word = Spec::Words; Spec::Entry* word = Spec::Words;
sw words_left = zpl_array_count ( Spec::Words); sw words_left = zpl_array_count ( Spec::Words);
do for ( ; words_left; words_left--, word++ )
{ {
if ( word->Sig[0] != line[0] ) if ( word->Sig[0] != src[0] )
continue; continue;
zpl_string_clear( current ); zpl_string_clear( current );
sw sig_length = zpl_string_length( word->Sig); sw sig_length = zpl_string_length( word->Sig);
current = zpl_string_append_length( current, line, sig_length ); current = zpl_string_append_length( current, src, sig_length );
if ( zpl_string_are_equal( word->Sig, current ) ) if ( zpl_string_are_equal( word->Sig, current ) )
{ {
char before = line[-1]; char before = src[-1];
char after = line[sig_length]; char after = src[sig_length];
if ( zpl_char_is_alphanumeric( before ) || before == '_' if ( zpl_char_is_alphanumeric( before ) || before == '_'
|| zpl_char_is_alphanumeric( after ) || after == '_' ) || zpl_char_is_alphanumeric( after ) || after == '_' )
@ -384,14 +412,12 @@ void refactor()
zpl_array_append( tokens, entry ); zpl_array_append( tokens, entry );
log_fmt("\nFound %-81s line %d", current, num_lines - left); log_fmt("\nFound %-81s line %d, column %d", current, line, col );
line += sig_length; move_forward( sig_length );
pos += sig_length;
goto Skip; goto Skip;
} }
} }
while ( word++, --words_left );
} }
// Namespaces to match // Namespaces to match
@ -400,20 +426,20 @@ void refactor()
sw nspaces_left = zpl_array_count( Spec::Namespaces); sw nspaces_left = zpl_array_count( Spec::Namespaces);
do for ( ; nspaces_left; nspaces_left--, nspace++ )
{ {
if ( nspace->Sig[0] != line[0] ) if ( nspace->Sig[0] != src[0] )
continue; continue;
zpl_string_clear( current ); zpl_string_clear( current );
u32 sig_length = zpl_string_length( nspace->Sig ); u32 sig_length = zpl_string_length( nspace->Sig );
current = zpl_string_append_length( current, line, sig_length ); current = zpl_string_append_length( current, src, sig_length );
if ( zpl_string_are_equal( nspace->Sig, current ) ) if ( zpl_string_are_equal( nspace->Sig, current ) )
{ {
u32 length = sig_length; u32 length = sig_length;
char* ns_content = line + sig_length; char const* ns_content = src + sig_length;
while ( zpl_char_is_alphanumeric( ns_content[0] ) || ns_content[0] == '_' ) while ( zpl_char_is_alphanumeric( ns_content[0] ) || ns_content[0] == '_' )
{ {
@ -439,26 +465,29 @@ void refactor()
#if Build_Debug #if Build_Debug
zpl_string_clear( preview ); zpl_string_clear( preview );
preview = zpl_string_append_length( preview, line, length); preview = zpl_string_append_length( preview, src, length);
log_fmt("\nFound %-40s %-40s line %d", preview, nspace->Sig, num_lines - left); log_fmt("\nFound %-40s %-40s line %d, column %d", preview, nspace->Sig, line, col );
#endif #endif
line += length; move_forward( length );
pos += length;
goto Skip; goto Skip;
} }
} }
while ( nspace++, --nspaces_left );
} }
Skip: Skip:
if ( line != '\0' ) if ( src[0] == '\n' )
goto Continue_Line; {
line++;
col = 0;
}
src++;
} }
while ( lines++, line = *lines, left ); while ( --left );
// Prep data for building the content // Prep data for building the content
left = IO::Current_Size; left = zpl_array_count( tokens);
char* content = IO::Current_Content; char* content = IO::Current_Content;
@ -475,17 +504,19 @@ void refactor()
sw sig_length = zpl_string_length( entry->Sig ); sw sig_length = zpl_string_length( entry->Sig );
// Append between tokens // Append between tokens
refactored = zpl_string_append_length( refactored, line, segment_length ); refactored = zpl_string_append_length( refactored, content, segment_length );
line += segment_length + sig_length; content += segment_length + sig_length;
segment_length = entry->End - entry->Start - sig_length; segment_length = entry->End - entry->Start - sig_length;
// Append token // Append token
if ( entry->Sub ) if ( entry->Sub )
refactored = zpl_string_append( refactored, entry->Sub ); {
refactored = zpl_string_append( refactored, entry->Sub );
}
refactored = zpl_string_append_length( refactored, line, segment_length ); refactored = zpl_string_append_length( refactored, content, segment_length );
line += segment_length; content += segment_length;
previous_end = entry->End; previous_end = entry->End;
entry++; entry++;
@ -496,11 +527,13 @@ void refactor()
if ( entry->End < IO::Current_Size ) if ( entry->End < IO::Current_Size )
{ {
refactored = zpl_string_append_length( refactored, line, IO::Current_Size - entry->End ); refactored = zpl_string_append_length( refactored, content, IO::Current_Size - 1 - entry->End );
} }
} }
IO::write( refactored ); IO::write( refactored );
zpl_string_clear( refactored );
} }
int main( int num, char** arguments ) int main( int num, char** arguments )
@ -520,6 +553,8 @@ int main( int num, char** arguments )
do do
{ {
refactor(); refactor();
zpl_printf("\nRefactored: %s", IO::Sources[IO::Current]);
} }
while ( --left ); while ( --left );

59
scripts/build.ps1
View File

@ -42,46 +42,39 @@ if ( $type )
Start-Process meson $args_meson -NoNewWindow -Wait -WorkingDirectory $path_scripts Start-Process meson $args_meson -NoNewWindow -Wait -WorkingDirectory $path_scripts
} }
#endregion Regular Build
#region Test Build
write-host "`n`nBuilding Test`n"
if ( -not( Test-Path $path_build ) )
{
return;
}
$args_ninja = @() $args_ninja = @()
$args_ninja += "-C" $args_ninja += "-C"
$args_ninja += $path_build $args_ninja += $path_build
Start-Process ninja $args_ninja -Wait -NoNewWindow -WorkingDirectory $path_root Start-Process ninja $args_ninja -Wait -NoNewWindow -WorkingDirectory $path_root
#endregion Regular Build
# Refactor thirdparty libraries
& .\refactor_and_format.ps1
if ( $test -eq $false ) if ( $test -eq $true -and (Test-Path $path_build) )
{ {
return; #region Test Build
write-host "`n`nBuilding Test`n"
# Refactor thirdparty libraries
& .\refactor_and_format.ps1
$path_test = Join-Path $path_root test
$path_test_build = Join-Path $path_test build
if ( -not( Test-Path $path_test_build ) )
{
$args_meson = @()
$args_meson += "setup"
$args_meson += $path_test_build
Start-Process meson $args_meson -NoNewWindow -Wait -WorkingDirectory $path_scripts
}
$args_ninja = @()
$args_ninja += "-C"
$args_ninja += $path_build
Start-Process ninja $args_ninja -Wait -NoNewWindow -WorkingDirectory $path_test
#endregion Test Build
} }
$path_test = Join-Path $path_root test
$path_test_build = Join-Path $path_test build
if ( -not( Test-Path $path_test_build ) )
{
$args_meson = @()
$args_meson += "setup"
$args_meson += $path_test_build
Start-Process meson $args_meson -NoNewWindow -Wait -WorkingDirectory $path_scripts
}
$args_ninja = @()
$args_ninja += "-C"
$args_ninja += $path_build
Start-Process ninja $args_ninja -Wait -NoNewWindow -WorkingDirectory $path_test
#endregion Test Build

2
scripts/get_sources.ps1
View File

@ -1,4 +1,4 @@
[string[]] $include = '*.c', '*.cc', '*.cpp' [string[]] $include = 'refactor.cpp' #'*.c', '*.cc', '*.cpp'
# [stirng[]] $exclude = # [stirng[]] $exclude =
$path_root = git rev-parse --show-toplevel $path_root = git rev-parse --show-toplevel