[Tool/Web/Other] Include file parser
#1

Hey,

I've gained interest in SA-MP scripting again; however, I'm a Mac user these days. In a quest to get PAWN syntax highlighting, auto-complete, etc. in TextMate (Mac text editor) I had to get information from the include files. I did manage to get all that working just great.
Anyway, at the bottom of this post is the script I ended up using. I figured someone might find it useful.

You give the function a string containing, for example, all your PAWN include files together. The function will return an array with tags, defines, and functions.

Example output: http://pastebay.com/138441

A short example of usage:
PHP Code:
<?php
    
require_once 'pawn_parser.php';
    
    function 
get_dir_contents($dir, $skip = array())
    {
        
$data = '';
        
$skip = array_flip(array_merge($skip, array('.', '..', '.DS_Store', 'Thumbs.db')));
    
        if (!
is_dir($dir)) {
            return 
'';
        }
        if ((
$d = dir($dir)) === false) {
            return 
'';
        }
    
        
$path = $d->path;
    
        while (
false !== ($entry = $d->read())) {
            if (isset(
$skip[$entry])) {
                continue;
            }
        
            
$entry = "$path/$entry";
        
            if (
is_dir($entry)) {
                
$data .= get_dir_contents($entry, $skip);
            } else if (
is_file($entry)) {
                
$data .= file_get_contents($entry) . "\n";
            }
        }
    
        
$d->close();
    
        return 
$data;
    }
    
$include_data = get_dir_contents('include'); // you gotta change this
    
$include_info = parse_pawn_includes($include_data);
    foreach (
$include_info->functions as $function) {
        if (
$function->type == 'forward') {
            echo 
"Callback: $function->name<br/>\n";
        }
    }
?>
The above code would output:
Code:
Callback: OnNPCModeInit
Callback: OnNPCModeExit
Callback: OnNPCConnect
Callback: OnNPCDisconnect
Callback: OnNPCSpawn
Callback: OnNPCEnterVehicle
Callback: OnNPCExitVehicle
Callback: OnClientMessage
Callback: OnPlayerDeath
Callback: OnPlayerText
Callback: OnPlayerStreamIn
Callback: OnPlayerStreamOut
Callback: OnVehicleStreamIn
Callback: OnVehicleStreamOut
Callback: OnRecordingPlaybackEnd
Callback: OnGameModeInit
Callback: OnGameModeExit
Callback: OnFilterScriptInit
Callback: OnFilterScriptExit
Callback: OnPlayerConnect
Callback: OnPlayerDisconnect
Callback: OnPlayerSpawn
Callback: OnPlayerDeath
Callback: OnVehicleSpawn
Callback: OnVehicleDeath
Callback: OnPlayerText
Callback: OnPlayerCommandText
Callback: OnPlayerRequestClass
Callback: OnPlayerEnterVehicle
Callback: OnPlayerExitVehicle
Callback: OnPlayerStateChange
Callback: OnPlayerEnterCheckpoint
Callback: OnPlayerLeaveCheckpoint
Callback: OnPlayerEnterRaceCheckpoint
Callback: OnPlayerLeaveRaceCheckpoint
Callback: OnRconCommand
Callback: OnPlayerRequestSpawn
Callback: OnObjectMoved
Callback: OnPlayerObjectMoved
Callback: OnPlayerPickUpPickup
Callback: OnVehicleMod
Callback: OnEnterExitModShop
Callback: OnVehiclePaintjob
Callback: OnVehicleRespray
Callback: OnVehicleDamageStatusUpdate
Callback: OnPlayerSelectedMenuRow
Callback: OnPlayerExitedMenu
Callback: OnPlayerInteriorChange
Callback: OnPlayerKeyStateChange
Callback: OnRconLoginAttempt
Callback: OnPlayerUpdate
Callback: OnPlayerStreamIn
Callback: OnPlayerStreamOut
Callback: OnVehicleStreamIn
Callback: OnVehicleStreamOut
Callback: OnDialogResponse
Callback: OnPlayerClickPlayer
Callback: @receivestring
Callback: @receivepacket
The script:
PHP Code:
<?php
    
function oneLineEnumerations($input)
    {
        return 
preg_replace('/\s+/', ' ', $input[0]);
    }
    
    function 
parse_pawn_includes($input) {
        
$input = preg_replace('#/\*[\s\S]*?\*/#', '', $input);
        
$input = preg_replace('#//.*#', '', $input);
        
$input = preg_replace_callback('/enum[\s\S]*?{[\s\S]*?}/', 'oneLineEnumerations', $input);
        
        
$functions = array();
        
$bad_args = array();
        
$all_tags = array();
        
$constants = array_flip(array('floatround_round', 'floatround_floor', 'floatround_ceil', 'floatround_tozero', 'floatround_unbiased', 'seek_start', 'seek_current', 'seek_end', 'EOS', 'cellbits', 'cellmax', 'cellmin', 'charbits', 'charmin', 'charmax', 'ucharmax', '__Pawn', 'debug', 'overlaysize', 'radian', 'degrees', 'grades'));
        
        foreach (
$constants as $constant => $v) {
            
$constants[$constant] = true;
        }
        
        foreach (
explode("\n", $input) as $line) {
            
$line = trim($line);
    
            if (empty(
$line)) {
                continue;
            }
    
            if (
preg_match('/^(native|forward)/', $line)) {
                if (
preg_match('/^(native|forward)\s+(?:([\S]+)\s*:\s*)?([^(]+)\s*\(\s*([^;]*)\s*\)\s*;/', $line, $matches)) {
                    
$type = $matches[1];
                    
$tag = $matches[2];
                    
$name = $matches[3];
                    
$arguments = $matches[4];
                    
                    if (
preg_match('/^operator.$/', $name)) {
                        continue;
                    }
            
                    
$arguments = preg_split('/\s*,(?![^{]+})\s*/', $arguments);
            
                    
$arguments_parsed = array();
            
                    foreach (
$arguments as &$argument) {
                        if (empty(
$argument)) {
                            continue;
                        }
                
                        if (
preg_match('/(const)?\s*(&)?\s*(?:([^:]+?)\s*:\s*)?(\.\.\.|\.\.|[@a-zA-Z0-9_]+)(\[.*\])?(?:.*=\s*(.+))?/', $argument, $matches)) {
                            
$arguments_match = array(
                                
'line' => $matches[0],
                                
'const' => $matches[1] == 'const',
                                
'reference' => $matches[2] == '&',
                                
'tags' => $matches[3],
                                
'name' => $matches[4],
                                
'length' => @$matches[5],
                                
'default' => @$matches[6],
                            );
                    
                            if (
preg_match('/{\s*(.*)\s*}/', $arguments_match['tags'], $matches)) {
                                
$arguments_match['tags'] = preg_split('/\s*,\s*/', $matches[1]);
                        
                                foreach (
$arguments_match['tags'] as $tag) {
                                    
$all_tags[$tag] = true;
                                }
                            } else {
                                
$arguments_match['tags'] = trim($arguments_match['tags']);
                        
                                if (!empty(
$arguments_match['tags'])) {
                                    
$all_tags[$arguments_match['tags']] = true;
                            
                                    
$arguments_match['tags'] = array($arguments_match['tags']);
                                } else {
                                    
$arguments_match['tags'] = array();
                                }
                            }
                    
                            if (!empty(
$arguments_match['length'])) {
                                if (
preg_match('/\[\s*(\S+)\s*\]/', $arguments_match['length'], $matches)) {
                                    
$arguments_match['length'] = (string) $matches[1];
                                } else {
                                    
$arguments_match['length'] = true;
                                }
                            } else {
                                
$arguments_match['length'] = null;
                            }
                    
                            
$arguments_parsed[] = (object) $arguments_match;
                        } else {
                            
$bad_args[] = $line;
                        }
                    }
            
                    unset(
$argument);
            
                    
$functions[] = (object) array(
                        
'type' => $type,
                        
'tag' => $tag,
                        
'name' => $name,
                        
'arguments' => $arguments_parsed,
                    );
                } else {
                    
//echo 'ERROR: ' . $line . "\n";
                
}
            } else if (
preg_match('/^#define\s+(\S+)\s*(\S+)?\s*/i', $line, $matches)) {
                
$constants[$matches[1]] = isset($matches[2]) ? $matches[2] : true;
            }
        }
        
        return array(
            
'functions' => $functions,
            
'constants' => $constants,
            
'tags' => array_keys($all_tags),
        );
    }
?>
Reply
#2

nice o.o
it detect inside pawno folder?
Reply
#3

Quote:
Originally Posted by |_ⒾⓇⓄN_ⒹⓄG_|
View Post
nice o.o
it detect inside pawno folder?
Well you could use it to scan any PAWN code, really. The most useful place is the include folder.
Reply
#4

Quote:
Originally Posted by Slice
View Post
Well you could use it to scan any PAWN code, really. The most useful place is the include folder.
hum well....nice
xd
+rep
Reply


Forum Jump:


Users browsing this thread: